Absyn.c File Reference

Go to the source code of this file.

Functions
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseExpShallowIterator (threadData_t *threadData, modelica_metatype _inIterator, modelica_metatype _inArg, modelica_fnptr _inFunc)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseExpShallowFuncArgs (threadData_t *threadData, modelica_metatype _inArgs, modelica_metatype _inArg, modelica_fnptr _inFunc)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseClassDef (threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseClassDef (threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseElementSpecComponents (threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseElementSpecComponents (threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseElementComponents (threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseElementComponents (threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseElementItemComponents (threadData_t *threadData, modelica_metatype _inItem, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseElementItemComponents (threadData_t *threadData, modelica_metatype _inItem, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseClassPartComponents (threadData_t *threadData, modelica_metatype _inClassPart, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseClassPartComponents (threadData_t *threadData, modelica_metatype _inClassPart, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseListGeneric (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_traverseListGeneric (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_getElementItemsInClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_dummyTraverseExp (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_getNamedAnnotationStr (threadData_t *threadData, modelica_metatype _inAbsynElementArgLst, modelica_metatype _id, modelica_fnptr _f)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_mergeAnnotations2 (threadData_t *threadData, modelica_metatype _oldmods, modelica_metatype _newmods)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_isInitialTraverseHelper (threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _inBool, modelica_boolean *out_outBool)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_isInitialTraverseHelper (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inBool, modelica_metatype *out_outBool)
PROTECTED_FUNCTION_STATIC modelica_boolean	omc_Absyn_isExternalPart (threadData_t *threadData, modelica_metatype _inClassPart)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_isExternalPart (threadData_t *threadData, modelica_metatype _inClassPart)
PROTECTED_FUNCTION_STATIC modelica_boolean	omc_Absyn_filterAnnotationItem (threadData_t *threadData, modelica_metatype _elt)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_filterAnnotationItem (threadData_t *threadData, modelica_metatype _elt)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_getFunctionInterfaceParts (threadData_t *threadData, modelica_metatype _part, modelica_metatype _elts)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_stripClassDefComment (threadData_t *threadData, modelica_metatype _cl)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_onlyLiteralsInExpExit (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_onlyLiteralsInExpEnter (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
PROTECTED_FUNCTION_STATIC modelica_boolean	omc_Absyn_onlyLiteralsInEqMod (threadData_t *threadData, modelica_metatype _eqMod)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_onlyLiteralsInEqMod (threadData_t *threadData, modelica_metatype _eqMod)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_getIteratorIndexedCrefs (threadData_t *threadData, modelica_metatype _inCref, modelica_string _inIterator, modelica_metatype _inCrefs)
PROTECTED_FUNCTION_STATIC modelica_boolean	omc_Absyn_iteratorIndexedCrefsEqual (threadData_t *threadData, modelica_metatype _inCref1, modelica_metatype _inCref2)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_iteratorIndexedCrefsEqual (threadData_t *threadData, modelica_metatype _inCref1, modelica_metatype _inCref2)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_findIteratorIndexedCrefs__traverser (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inCrefs, modelica_string _inIterator, modelica_metatype *out_outCrefs)
PROTECTED_FUNCTION_STATIC modelica_boolean	omc_Absyn_functionArgsEqual (threadData_t *threadData, modelica_metatype _args1, modelica_metatype _args2)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_functionArgsEqual (threadData_t *threadData, modelica_metatype _args1, modelica_metatype _args2)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_getCrefFromNarg (threadData_t *threadData, modelica_metatype _inNamedArg, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_getCrefFromNarg (threadData_t *threadData, modelica_metatype _inNamedArg, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_pathToStringListWork (threadData_t *threadData, modelica_metatype _path, modelica_metatype _acc)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_stringListPathReversed2 (threadData_t *threadData, modelica_metatype _inStrings, modelica_metatype _inAccumPath)
PROTECTED_FUNCTION_STATIC modelica_string	omc_Absyn_pathStringWork (threadData_t *threadData, modelica_metatype _inPath, modelica_integer _len, modelica_string _delimiter, modelica_integer _dlen, modelica_boolean _reverse)
PROTECTED_FUNCTION_STATIC modelica_metatype	boxptr_Absyn_pathStringWork (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _len, modelica_metatype _delimiter, modelica_metatype _dlen, modelica_metatype _reverse)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseAlgorithmBidir (threadData_t *threadData, modelica_metatype _inAlg, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseAlgorithmBidirElse (threadData_t *threadData, modelica_metatype _inElse, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseEquationBidirElse (threadData_t *threadData, modelica_metatype _inElse, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseEquationItemBidir (threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseAlgorithmItemBidir (threadData_t *threadData, modelica_metatype _inAlgorithmItem, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseAlgorithmItemListBidir (threadData_t *threadData, modelica_metatype _inAlgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseEquationItemListBidir (threadData_t *threadData, modelica_metatype _inEquationItems, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseClassPartBidir (threadData_t *threadData, modelica_metatype _cp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseExpBidirSubExps (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
PROTECTED_FUNCTION_STATIC modelica_metatype	omc_Absyn_traverseEquationItem (threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_integer	omc_Absyn_pathPartCount (threadData_t *threadData, modelica_metatype _path, modelica_integer _partsAccum)
modelica_metatype	boxptr_Absyn_pathPartCount (threadData_t *threadData, modelica_metatype _path, modelica_metatype _partsAccum)
DLLExport modelica_metatype	omc_Absyn_isInvariantExpNoTraverse (threadData_t *threadData, modelica_metatype _ $in_e, modelica_boolean _ $in_b, modelica_boolean *out_b)
modelica_metatype	boxptr_Absyn_isInvariantExpNoTraverse (threadData_t *threadData, modelica_metatype _ $in_e, modelica_metatype _ $in_b, modelica_metatype *out_b)
DLLExport modelica_boolean	omc_Absyn_isEmptyClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
modelica_metatype	boxptr_Absyn_isEmptyClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
DLLExport modelica_boolean	omc_Absyn_isElementItemClassNamed (threadData_t *threadData, modelica_string _inName, modelica_metatype _inElement)
modelica_metatype	boxptr_Absyn_isElementItemClassNamed (threadData_t *threadData, modelica_metatype _inName, modelica_metatype _inElement)
DLLExport modelica_boolean	omc_Absyn_isAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlg)
modelica_metatype	boxptr_Absyn_isAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlg)
DLLExport modelica_boolean	omc_Absyn_isElementItem (threadData_t *threadData, modelica_metatype _inElement)
modelica_metatype	boxptr_Absyn_isElementItem (threadData_t *threadData, modelica_metatype _inElement)
DLLExport modelica_boolean	omc_Absyn_isElementItemClass (threadData_t *threadData, modelica_metatype _inElement)
modelica_metatype	boxptr_Absyn_isElementItemClass (threadData_t *threadData, modelica_metatype _inElement)
DLLExport modelica_metatype	omc_Absyn_traverseExpShallow (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inArg, modelica_fnptr _inFunc)
DLLExport modelica_metatype	omc_Absyn_crefExplode (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inAccum)
DLLExport modelica_metatype	omc_Absyn_makeSubscript (threadData_t *threadData, modelica_metatype _inExp)
DLLExport modelica_metatype	omc_Absyn_optMsg (threadData_t *threadData, modelica_boolean _inShowMessage, modelica_metatype _inInfo)
modelica_metatype	boxptr_Absyn_optMsg (threadData_t *threadData, modelica_metatype _inShowMessage, modelica_metatype _inInfo)
DLLExport modelica_boolean	omc_Absyn_elementArgEqualName (threadData_t *threadData, modelica_metatype _inArg1, modelica_metatype _inArg2)
modelica_metatype	boxptr_Absyn_elementArgEqualName (threadData_t *threadData, modelica_metatype _inArg1, modelica_metatype _inArg2)
DLLExport modelica_metatype	omc_Absyn_elementArgName (threadData_t *threadData, modelica_metatype _inArg)
DLLExport modelica_boolean	omc_Absyn_isEmptySubMod (threadData_t *threadData, modelica_metatype _inSubMod)
modelica_metatype	boxptr_Absyn_isEmptySubMod (threadData_t *threadData, modelica_metatype _inSubMod)
DLLExport modelica_boolean	omc_Absyn_isEmptyMod (threadData_t *threadData, modelica_metatype _inMod)
modelica_metatype	boxptr_Absyn_isEmptyMod (threadData_t *threadData, modelica_metatype _inMod)
DLLExport modelica_metatype	omc_Absyn_traverseClassComponents (threadData_t *threadData, modelica_metatype _inClass, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_getElementItemsInClass (threadData_t *threadData, modelica_metatype _inClass)
DLLExport modelica_metatype	omc_Absyn_getDefineUnitsInElements (threadData_t *threadData, modelica_metatype _elts)
DLLExport modelica_boolean	omc_Absyn_opIsElementWise (threadData_t *threadData, modelica_metatype _op)
modelica_metatype	boxptr_Absyn_opIsElementWise (threadData_t *threadData, modelica_metatype _op)
DLLExport modelica_boolean	omc_Absyn_opEqual (threadData_t *threadData, modelica_metatype _op1, modelica_metatype _op2)
modelica_metatype	boxptr_Absyn_opEqual (threadData_t *threadData, modelica_metatype _op1, modelica_metatype _op2)
DLLExport modelica_metatype	omc_Absyn_mapCrefParts (threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _inMapFunc)
DLLExport modelica_metatype	omc_Absyn_getNamedAnnotationInClass (threadData_t *threadData, modelica_metatype _inClass, modelica_metatype _id, modelica_fnptr _f)
DLLExport modelica_metatype	omc_Absyn_removeCrefFromCrefs (threadData_t *threadData, modelica_metatype _inAbsynComponentRefLst, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_getArrayDimOptAsList (threadData_t *threadData, modelica_metatype _inArrayDim)
DLLExport modelica_string	omc_Absyn_refStringBrief (threadData_t *threadData, modelica_metatype _inRef)
DLLExport modelica_string	omc_Absyn_refString (threadData_t *threadData, modelica_metatype _inRef)
DLLExport modelica_string	omc_Absyn_importString (threadData_t *threadData, modelica_metatype _inImp)
DLLExport modelica_string	omc_Absyn_crefStringIgnoreSubs (threadData_t *threadData, modelica_metatype _inCr)
DLLExport modelica_string	omc_Absyn_typeSpecStringNoQualNoDimsLst (threadData_t *threadData, modelica_metatype _inTypeSpecLst)
DLLExport modelica_string	omc_Absyn_typeSpecStringNoQualNoDims (threadData_t *threadData, modelica_metatype _inTs)
DLLExport modelica_string	omc_Absyn_crefString (threadData_t *threadData, modelica_metatype _inCr)
DLLExport modelica_string	omc_Absyn_typeSpecString (threadData_t *threadData, modelica_metatype _inTs)
DLLExport modelica_metatype	omc_Absyn_pathToTypeSpec (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_annotationToElementArgs (threadData_t *threadData, modelica_metatype _ann)
DLLExport modelica_metatype	omc_Absyn_subModsInSameOrder (threadData_t *threadData, modelica_metatype _oldmod, modelica_metatype _newmod)
DLLExport modelica_boolean	omc_Absyn_isModificationOfPath (threadData_t *threadData, modelica_metatype _mod, modelica_metatype _path)
modelica_metatype	boxptr_Absyn_isModificationOfPath (threadData_t *threadData, modelica_metatype _mod, modelica_metatype _path)
DLLExport modelica_metatype	omc_Absyn_mergeCommentAnnotation (threadData_t *threadData, modelica_metatype _inAnnotation, modelica_metatype _inComment)
DLLExport modelica_metatype	omc_Absyn_mergeAnnotations (threadData_t *threadData, modelica_metatype _inAnnotation1, modelica_metatype _inAnnotation2)
DLLExport modelica_string	omc_Absyn_importName (threadData_t *threadData, modelica_metatype _inImport)
DLLExport modelica_metatype	omc_Absyn_importPath (threadData_t *threadData, modelica_metatype _inImport)
DLLExport modelica_boolean	omc_Absyn_isInitial (threadData_t *threadData, modelica_metatype _inExp)
modelica_metatype	boxptr_Absyn_isInitial (threadData_t *threadData, modelica_metatype _inExp)
DLLExport modelica_boolean	omc_Absyn_expContainsInitial (threadData_t *threadData, modelica_metatype _inExp)
modelica_metatype	boxptr_Absyn_expContainsInitial (threadData_t *threadData, modelica_metatype _inExp)
DLLExport modelica_metatype	omc_Absyn_pathSetLastIdent (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inLastIdent)
DLLExport modelica_string	omc_Absyn_componentName (threadData_t *threadData, modelica_metatype _c)
DLLExport modelica_metatype	omc_Absyn_makeClassElement (threadData_t *threadData, modelica_metatype _cl)
DLLExport modelica_boolean	omc_Absyn_isParts (threadData_t *threadData, modelica_metatype _cl)
modelica_metatype	boxptr_Absyn_isParts (threadData_t *threadData, modelica_metatype _cl)
DLLExport modelica_metatype	omc_Absyn_getExternalDecl (threadData_t *threadData, modelica_metatype _inCls)
DLLExport modelica_metatype	omc_Absyn_getFunctionInterface (threadData_t *threadData, modelica_metatype _cl)
DLLExport modelica_metatype	omc_Absyn_getShortClass (threadData_t *threadData, modelica_metatype _cl)
DLLExport modelica_boolean	omc_Absyn_pathGe (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
modelica_metatype	boxptr_Absyn_pathGe (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
DLLExport modelica_boolean	omc_Absyn_pathLt (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
modelica_metatype	boxptr_Absyn_pathLt (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
DLLExport modelica_boolean	omc_Absyn_isFieldEqual (threadData_t *threadData, modelica_metatype _isField1, modelica_metatype _isField2)
modelica_metatype	boxptr_Absyn_isFieldEqual (threadData_t *threadData, modelica_metatype _isField1, modelica_metatype _isField2)
DLLExport modelica_boolean	omc_Absyn_directionEqual (threadData_t *threadData, modelica_metatype _inDirection1, modelica_metatype _inDirection2)
modelica_metatype	boxptr_Absyn_directionEqual (threadData_t *threadData, modelica_metatype _inDirection1, modelica_metatype _inDirection2)
DLLExport modelica_boolean	omc_Absyn_isOutput (threadData_t *threadData, modelica_metatype _inDirection)
modelica_metatype	boxptr_Absyn_isOutput (threadData_t *threadData, modelica_metatype _inDirection)
DLLExport modelica_boolean	omc_Absyn_isInput (threadData_t *threadData, modelica_metatype _inDirection)
modelica_metatype	boxptr_Absyn_isInput (threadData_t *threadData, modelica_metatype _inDirection)
DLLExport modelica_boolean	omc_Absyn_isInputOrOutput (threadData_t *threadData, modelica_metatype _direction)
modelica_metatype	boxptr_Absyn_isInputOrOutput (threadData_t *threadData, modelica_metatype _direction)
DLLExport modelica_boolean	omc_Absyn_getExpsFromArrayDim__tail (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
modelica_metatype	boxptr_Absyn_getExpsFromArrayDim__tail (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
DLLExport modelica_boolean	omc_Absyn_getExpsFromArrayDimOpt (threadData_t *threadData, modelica_metatype _inAdO, modelica_metatype *out_outExps)
modelica_metatype	boxptr_Absyn_getExpsFromArrayDimOpt (threadData_t *threadData, modelica_metatype _inAdO, modelica_metatype *out_outExps)
DLLExport modelica_boolean	omc_Absyn_getExpsFromArrayDim (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype *out_outExps)
modelica_metatype	boxptr_Absyn_getExpsFromArrayDim (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype *out_outExps)
DLLExport void	omc_Absyn_isDerCrefFail (threadData_t *threadData, modelica_metatype _exp)
DLLExport modelica_boolean	omc_Absyn_isDerCref (threadData_t *threadData, modelica_metatype _exp)
modelica_metatype	boxptr_Absyn_isDerCref (threadData_t *threadData, modelica_metatype _exp)
DLLExport modelica_boolean	omc_Absyn_isTuple (threadData_t *threadData, modelica_metatype _inExp)
modelica_metatype	boxptr_Absyn_isTuple (threadData_t *threadData, modelica_metatype _inExp)
DLLExport modelica_boolean	omc_Absyn_isCref (threadData_t *threadData, modelica_metatype _exp)
modelica_metatype	boxptr_Absyn_isCref (threadData_t *threadData, modelica_metatype _exp)
DLLExport modelica_metatype	omc_Absyn_crefInsertSubscriptLstLst2 (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubs)
DLLExport modelica_metatype	omc_Absyn_crefInsertSubscriptLstLst (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
DLLExport modelica_metatype	omc_Absyn_subscriptExpOpt (threadData_t *threadData, modelica_metatype _inSub)
DLLExport modelica_string	omc_Absyn_innerOuterStr (threadData_t *threadData, modelica_metatype _io)
DLLExport modelica_metatype	omc_Absyn_joinWithinPath (threadData_t *threadData, modelica_metatype _within_, modelica_metatype _path)
DLLExport modelica_string	omc_Absyn_withinString (threadData_t *threadData, modelica_metatype _w1)
DLLExport modelica_boolean	omc_Absyn_withinEqual (threadData_t *threadData, modelica_metatype _within1, modelica_metatype _within2)
modelica_metatype	boxptr_Absyn_withinEqual (threadData_t *threadData, modelica_metatype _within1, modelica_metatype _within2)
DLLExport modelica_boolean	omc_Absyn_pathIsQual (threadData_t *threadData, modelica_metatype _inPath)
modelica_metatype	boxptr_Absyn_pathIsQual (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_boolean	omc_Absyn_pathIsIdent (threadData_t *threadData, modelica_metatype _inPath)
modelica_metatype	boxptr_Absyn_pathIsIdent (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_boolean	omc_Absyn_pathIsFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
modelica_metatype	boxptr_Absyn_pathIsFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_unqualifyCref (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_metatype	omc_Absyn_unqotePathIdents (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_string	omc_Absyn_crefIdent (threadData_t *threadData, modelica_metatype _cr)
DLLExport modelica_metatype	omc_Absyn_makeCons (threadData_t *threadData, modelica_metatype _e1, modelica_metatype _e2)
DLLExport modelica_boolean	omc_Absyn_onlyLiteralsInAnnotationMod (threadData_t *threadData, modelica_metatype _inMod)
modelica_metatype	boxptr_Absyn_onlyLiteralsInAnnotationMod (threadData_t *threadData, modelica_metatype _inMod)
DLLExport modelica_metatype	omc_Absyn_canonIfExp (threadData_t *threadData, modelica_metatype _inExp)
DLLExport modelica_boolean	omc_Absyn_importEqual (threadData_t *threadData, modelica_metatype _im1, modelica_metatype _im2)
modelica_metatype	boxptr_Absyn_importEqual (threadData_t *threadData, modelica_metatype _im1, modelica_metatype _im2)
DLLExport modelica_metatype	omc_Absyn_makeNotFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_makeFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_boolean	omc_Absyn_innerOuterEqual (threadData_t *threadData, modelica_metatype _io1, modelica_metatype _io2)
modelica_metatype	boxptr_Absyn_innerOuterEqual (threadData_t *threadData, modelica_metatype _io1, modelica_metatype _io2)
DLLExport modelica_boolean	omc_Absyn_isNotInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
modelica_metatype	boxptr_Absyn_isNotInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
DLLExport modelica_boolean	omc_Absyn_isInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
modelica_metatype	boxptr_Absyn_isInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
DLLExport modelica_boolean	omc_Absyn_isOnlyOuter (threadData_t *threadData, modelica_metatype _inIO)
modelica_metatype	boxptr_Absyn_isOnlyOuter (threadData_t *threadData, modelica_metatype _inIO)
DLLExport modelica_boolean	omc_Absyn_isOnlyInner (threadData_t *threadData, modelica_metatype _inIO)
modelica_metatype	boxptr_Absyn_isOnlyInner (threadData_t *threadData, modelica_metatype _inIO)
DLLExport modelica_boolean	omc_Absyn_isInner (threadData_t *threadData, modelica_metatype _io)
modelica_metatype	boxptr_Absyn_isInner (threadData_t *threadData, modelica_metatype _io)
DLLExport modelica_boolean	omc_Absyn_isOuter (threadData_t *threadData, modelica_metatype _io)
modelica_metatype	boxptr_Absyn_isOuter (threadData_t *threadData, modelica_metatype _io)
DLLExport modelica_string	omc_Absyn_getFileNameFromInfo (threadData_t *threadData, modelica_metatype _inInfo)
DLLExport modelica_metatype	omc_Absyn_pathReplaceIdent (threadData_t *threadData, modelica_metatype _path, modelica_string _last)
DLLExport modelica_metatype	omc_Absyn_findIteratorIndexedCrefs (threadData_t *threadData, modelica_metatype _inExp, modelica_string _inIterator, modelica_metatype _inCrefs)
DLLExport modelica_string	omc_Absyn_getClassName (threadData_t *threadData, modelica_metatype _inClass)
DLLExport modelica_boolean	omc_Absyn_eachEqual (threadData_t *threadData, modelica_metatype _each1, modelica_metatype _each2)
modelica_metatype	boxptr_Absyn_eachEqual (threadData_t *threadData, modelica_metatype _each1, modelica_metatype _each2)
DLLExport modelica_boolean	omc_Absyn_expEqual (threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
modelica_metatype	boxptr_Absyn_expEqual (threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
DLLExport modelica_boolean	omc_Absyn_isFunctionRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
modelica_metatype	boxptr_Absyn_isFunctionRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
DLLExport modelica_boolean	omc_Absyn_isPackageRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
modelica_metatype	boxptr_Absyn_isPackageRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
DLLExport modelica_boolean	omc_Absyn_crefEqualNoSubs (threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
modelica_metatype	boxptr_Absyn_crefEqualNoSubs (threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
DLLExport modelica_boolean	omc_Absyn_subscriptsEqual (threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
modelica_metatype	boxptr_Absyn_subscriptsEqual (threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
DLLExport modelica_boolean	omc_Absyn_subscriptEqual (threadData_t *threadData, modelica_metatype _inSubscript1, modelica_metatype _inSubscript2)
modelica_metatype	boxptr_Absyn_subscriptEqual (threadData_t *threadData, modelica_metatype _inSubscript1, modelica_metatype _inSubscript2)
DLLExport modelica_boolean	omc_Absyn_crefFirstEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
modelica_metatype	boxptr_Absyn_crefFirstEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
DLLExport modelica_boolean	omc_Absyn_crefEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
modelica_metatype	boxptr_Absyn_crefEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
DLLExport modelica_metatype	omc_Absyn_setClassBody (threadData_t *threadData, modelica_metatype _inClass, modelica_metatype _inBody)
DLLExport modelica_metatype	omc_Absyn_setClassName (threadData_t *threadData, modelica_metatype _inClass, modelica_string _newName)
DLLExport modelica_metatype	omc_Absyn_setClassFilename (threadData_t *threadData, modelica_metatype _inClass, modelica_string _fileName)
DLLExport modelica_string	omc_Absyn_classFilename (threadData_t *threadData, modelica_metatype _inClass)
DLLExport modelica_metatype	omc_Absyn_lastClassname (threadData_t *threadData, modelica_metatype _inProgram)
DLLExport modelica_string	omc_Absyn_restrString (threadData_t *threadData, modelica_metatype _inRestriction)
DLLExport modelica_metatype	omc_Absyn_crefMakeFullyQualified (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_boolean	omc_Absyn_crefIsFullyQualified (threadData_t *threadData, modelica_metatype _inCref)
modelica_metatype	boxptr_Absyn_crefIsFullyQualified (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_metatype	omc_Absyn_crefStripFirst (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_crefFirstCref (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_string	omc_Absyn_crefSecondIdent (threadData_t *threadData, modelica_metatype _cref)
DLLExport modelica_string	omc_Absyn_crefFirstIdent (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_metatype	omc_Absyn_joinCrefs (threadData_t *threadData, modelica_metatype _inComponentRef1, modelica_metatype _inComponentRef2)
DLLExport modelica_metatype	omc_Absyn_crefStripLastSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_crefGetLastIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_getSubsFromCref (threadData_t *threadData, modelica_metatype _cr, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
modelica_metatype	boxptr_Absyn_getSubsFromCref (threadData_t *threadData, modelica_metatype _cr, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
DLLExport modelica_boolean	omc_Absyn_crefHasSubscripts (threadData_t *threadData, modelica_metatype _cref)
modelica_metatype	boxptr_Absyn_crefHasSubscripts (threadData_t *threadData, modelica_metatype _cref)
DLLExport modelica_metatype	omc_Absyn_crefSetLastSubs (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubscripts)
DLLExport modelica_metatype	omc_Absyn_crefLastSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_boolean	omc_Absyn_crefIsQual (threadData_t *threadData, modelica_metatype _inComponentRef)
modelica_metatype	boxptr_Absyn_crefIsQual (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_boolean	omc_Absyn_crefIsIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
modelica_metatype	boxptr_Absyn_crefIsIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_string	omc_Absyn_crefFirstIdentNoSubs (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_string	omc_Absyn_crefLastIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_pathToCrefWithSubs (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inSubs)
DLLExport modelica_metatype	omc_Absyn_pathToCref (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_crefToPathIgnoreSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_elementSpecToPath (threadData_t *threadData, modelica_metatype _inElementSpec)
DLLExport modelica_metatype	omc_Absyn_crefToPath (threadData_t *threadData, modelica_metatype _inComponentRef)
DLLExport modelica_metatype	omc_Absyn_stripFirst (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_splitQualAndIdentPath (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype *out_outPath2)
DLLExport modelica_metatype	omc_Absyn_crefStripLast (threadData_t *threadData, modelica_metatype _inCref)
DLLExport modelica_metatype	omc_Absyn_stripLastOpt (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_stripLast (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_pathAppendList (threadData_t *threadData, modelica_metatype _inPathLst)
DLLExport modelica_metatype	omc_Absyn_selectPathsOpt (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_metatype	omc_Absyn_joinPathsOptSuffix (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_metatype	omc_Absyn_joinPathsOpt (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_metatype	omc_Absyn_joinPaths (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_metatype	omc_Absyn_getNamedFuncArgNamesAndValues (threadData_t *threadData, modelica_metatype _inNamedArgList, modelica_metatype *out_outExpList)
DLLExport modelica_metatype	omc_Absyn_iteratorGuard (threadData_t *threadData, modelica_metatype _iterator)
DLLExport modelica_metatype	omc_Absyn_iteratorRange (threadData_t *threadData, modelica_metatype _iterator)
DLLExport modelica_string	omc_Absyn_iteratorName (threadData_t *threadData, modelica_metatype _iterator)
DLLExport modelica_metatype	omc_Absyn_getCrefFromFarg (threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
modelica_metatype	boxptr_Absyn_getCrefFromFarg (threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
DLLExport modelica_metatype	omc_Absyn_getCrefFromExp (threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
modelica_metatype	boxptr_Absyn_getCrefFromExp (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
DLLExport modelica_metatype	omc_Absyn_getCrefsFromSubs (threadData_t *threadData, modelica_metatype _isubs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
modelica_metatype	boxptr_Absyn_getCrefsFromSubs (threadData_t *threadData, modelica_metatype _isubs, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
DLLExport modelica_metatype	omc_Absyn_pathContainedIn (threadData_t *threadData, modelica_metatype _subPath, modelica_metatype _path)
DLLExport modelica_boolean	omc_Absyn_pathContainsString (threadData_t *threadData, modelica_metatype _p1, modelica_string _str)
modelica_metatype	boxptr_Absyn_pathContainsString (threadData_t *threadData, modelica_metatype _p1, modelica_metatype _str)
DLLExport modelica_boolean	omc_Absyn_pathContains (threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
modelica_metatype	boxptr_Absyn_pathContains (threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
DLLExport modelica_metatype	omc_Absyn_crefRemovePrefix (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
DLLExport modelica_metatype	omc_Absyn_removePartialPrefix (threadData_t *threadData, modelica_metatype _inPrefix, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_removePrefix (threadData_t *threadData, modelica_metatype _prefix_path, modelica_metatype _path)
DLLExport modelica_boolean	omc_Absyn_crefPrefixOf (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
modelica_metatype	boxptr_Absyn_crefPrefixOf (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
DLLExport modelica_boolean	omc_Absyn_pathPrefixOf (threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
modelica_metatype	boxptr_Absyn_pathPrefixOf (threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
DLLExport modelica_metatype	omc_Absyn_crefReplaceFirstIdent (threadData_t *threadData, modelica_metatype _icref, modelica_metatype _replPath)
DLLExport modelica_metatype	omc_Absyn_addSubscriptsLast (threadData_t *threadData, modelica_metatype _icr, modelica_metatype _i)
DLLExport modelica_metatype	omc_Absyn_pathReplaceFirstIdent (threadData_t *threadData, modelica_metatype _path, modelica_metatype _replPath)
DLLExport modelica_metatype	omc_Absyn_pathToStringList (threadData_t *threadData, modelica_metatype _path)
DLLExport modelica_boolean	omc_Absyn_pathSuffixOfr (threadData_t *threadData, modelica_metatype _path, modelica_metatype _suffix_path)
modelica_metatype	boxptr_Absyn_pathSuffixOfr (threadData_t *threadData, modelica_metatype _path, modelica_metatype _suffix_path)
DLLExport modelica_boolean	omc_Absyn_pathSuffixOf (threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
modelica_metatype	boxptr_Absyn_pathSuffixOf (threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
DLLExport modelica_metatype	omc_Absyn_suffixPath (threadData_t *threadData, modelica_metatype _inPath, modelica_string _inSuffix)
DLLExport modelica_metatype	omc_Absyn_prefixOptPath (threadData_t *threadData, modelica_string _prefix, modelica_metatype _optPath)
DLLExport modelica_metatype	omc_Absyn_prefixPath (threadData_t *threadData, modelica_string _prefix, modelica_metatype _path)
DLLExport modelica_metatype	omc_Absyn_pathPrefix (threadData_t *threadData, modelica_metatype _path)
DLLExport modelica_metatype	omc_Absyn_pathStripSamePrefix (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_metatype	omc_Absyn_pathRest (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_string	omc_Absyn_pathSecondIdent (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_pathFirstPath (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_string	omc_Absyn_pathFirstIdent (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_pathLast (threadData_t *threadData, modelica_metatype _ $in_path)
DLLExport modelica_string	omc_Absyn_pathLastIdent (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_pathTwoLastIdents (threadData_t *threadData, modelica_metatype _inPath)
DLLExport modelica_metatype	omc_Absyn_stringListPathReversed (threadData_t *threadData, modelica_metatype _inStrings)
DLLExport modelica_metatype	omc_Absyn_stringListPath (threadData_t *threadData, modelica_metatype _paths)
DLLExport modelica_metatype	omc_Absyn_stringPath (threadData_t *threadData, modelica_string _str)
DLLExport modelica_string	omc_Absyn_pathStringUnquoteReplaceDot (threadData_t *threadData, modelica_metatype _inPath, modelica_string _repStr)
DLLExport modelica_string	omc_Absyn_optPathString (threadData_t *threadData, modelica_metatype _inPathOption)
DLLExport modelica_integer	omc_Absyn_pathHashModWork (threadData_t *threadData, modelica_metatype _path, modelica_integer _acc)
modelica_metatype	boxptr_Absyn_pathHashModWork (threadData_t *threadData, modelica_metatype _path, modelica_metatype _acc)
DLLExport modelica_integer	omc_Absyn_pathHashMod (threadData_t *threadData, modelica_metatype _path, modelica_integer _mod)
modelica_metatype	boxptr_Absyn_pathHashMod (threadData_t *threadData, modelica_metatype _path, modelica_metatype _mod)
DLLExport modelica_integer	omc_Absyn_pathCompareNoQual (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
modelica_metatype	boxptr_Absyn_pathCompareNoQual (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
DLLExport modelica_integer	omc_Absyn_pathCompare (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
modelica_metatype	boxptr_Absyn_pathCompare (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
DLLExport modelica_boolean	omc_Absyn_classNameGreater (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
modelica_metatype	boxptr_Absyn_classNameGreater (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
DLLExport modelica_integer	omc_Absyn_classNameCompare (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
modelica_metatype	boxptr_Absyn_classNameCompare (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
DLLExport modelica_string	omc_Absyn_pathStringDefault (threadData_t *threadData, modelica_metatype _path)
DLLExport modelica_string	omc_Absyn_pathStringNoQual (threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
modelica_metatype	boxptr_Absyn_pathStringNoQual (threadData_t *threadData, modelica_metatype _path, modelica_metatype _delimiter, modelica_metatype _usefq, modelica_metatype _reverse)
DLLExport modelica_string	omc_Absyn_pathString (threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
modelica_metatype	boxptr_Absyn_pathString (threadData_t *threadData, modelica_metatype _path, modelica_metatype _delimiter, modelica_metatype _usefq, modelica_metatype _reverse)
DLLExport modelica_metatype	omc_Absyn_typeSpecDimensions (threadData_t *threadData, modelica_metatype _inTypeSpec)
DLLExport modelica_metatype	omc_Absyn_typeSpecPath (threadData_t *threadData, modelica_metatype _tp)
DLLExport modelica_string	omc_Absyn_typeSpecPathString (threadData_t *threadData, modelica_metatype _tp)
DLLExport modelica_boolean	omc_Absyn_optArrayDimEqual (threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
modelica_metatype	boxptr_Absyn_optArrayDimEqual (threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
DLLExport modelica_boolean	omc_Absyn_typeSpecEqual (threadData_t *threadData, modelica_metatype _a, modelica_metatype _b)
modelica_metatype	boxptr_Absyn_typeSpecEqual (threadData_t *threadData, modelica_metatype _a, modelica_metatype _b)
DLLExport modelica_boolean	omc_Absyn_pathEqual (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
modelica_metatype	boxptr_Absyn_pathEqual (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
DLLExport modelica_string	omc_Absyn_printComponentRefStr (threadData_t *threadData, modelica_metatype _cr)
DLLExport modelica_string	omc_Absyn_expComponentRefStr (threadData_t *threadData, modelica_metatype _aexp)
DLLExport modelica_metatype	omc_Absyn_crefExp (threadData_t *threadData, modelica_metatype _cr)
DLLExport modelica_metatype	omc_Absyn_expCref (threadData_t *threadData, modelica_metatype _exp)
DLLExport modelica_string	omc_Absyn_expString (threadData_t *threadData, modelica_metatype _exp)
DLLExport modelica_string	omc_Absyn_printImportString (threadData_t *threadData, modelica_metatype _imp)
DLLExport modelica_boolean	omc_Absyn_isClassdef (threadData_t *threadData, modelica_metatype _inElement)
modelica_metatype	boxptr_Absyn_isClassdef (threadData_t *threadData, modelica_metatype _inElement)
DLLExport modelica_string	omc_Absyn_elementSpecName (threadData_t *threadData, modelica_metatype _inElementSpec)
DLLExport modelica_boolean	omc_Absyn_isClassNamed (threadData_t *threadData, modelica_string _inName, modelica_metatype _inClass)
modelica_metatype	boxptr_Absyn_isClassNamed (threadData_t *threadData, modelica_metatype _inName, modelica_metatype _inClass)
DLLExport modelica_metatype	omc_Absyn_className (threadData_t *threadData, modelica_metatype _cl)
DLLExport modelica_metatype	omc_Absyn_makeQualifiedPathFromStrings (threadData_t *threadData, modelica_string _s1, modelica_string _s2)
DLLExport modelica_metatype	omc_Absyn_makeIdentPathFromString (threadData_t *threadData, modelica_string _s)
DLLExport modelica_metatype	omc_Absyn_traverseEquationBidir (threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseMatchCase (threadData_t *threadData, modelica_metatype _inMatchCase, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirIterator (threadData_t *threadData, modelica_metatype _inIterator, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirNamedArg (threadData_t *threadData, modelica_metatype _inArg, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inExtra, modelica_metatype *out_outExtra)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirFunctionArgs (threadData_t *threadData, modelica_metatype _inArgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirElseIf (threadData_t *threadData, modelica_metatype _inElseIf, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirSubs (threadData_t *threadData, modelica_metatype _inSubscript, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidirCref (threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
DLLExport modelica_metatype	omc_Absyn_traverseExpOptBidir (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
DLLExport modelica_metatype	omc_Absyn_traverseExpBidir (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
DLLExport modelica_metatype	omc_Absyn_traverseExpListBidir (threadData_t *threadData, modelica_metatype _inExpl, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpList (threadData_t *threadData, modelica_metatype _inExpList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpTopDown (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExp (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
DLLExport modelica_metatype	omc_Absyn_traverseExpAlgItemTupleList (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseAlgorithmItemList (threadData_t *threadData, modelica_metatype _inAlgorithmItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlgorithmItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseAlgorithm (threadData_t *threadData, modelica_metatype _inAlgorithm, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseExpEqItemTupleList (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseEquationItemList (threadData_t *threadData, modelica_metatype _inEquationItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
DLLExport modelica_metatype	omc_Absyn_traverseEquation (threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _inFunc, modelica_metatype _inTypeA)

Function Documentation

boxptr_Absyn_classNameCompare()

modelica_metatype boxptr_Absyn_classNameCompare	(	threadData_t *	threadData,
		modelica_metatype	_c1,
		modelica_metatype	_c2
	)

Definition at line 16704 of file Absyn.c.

{
  modelica_integer _o;
  modelica_metatype out_o;
  _o = omc_Absyn_classNameCompare(threadData, _c1, _c2);
  out_o = mmc_mk_icon(_o);
  return out_o;
}

Here is the call graph for this function:

boxptr_Absyn_classNameGreater()

modelica_metatype boxptr_Absyn_classNameGreater	(	threadData_t *	threadData,
		modelica_metatype	_c1,
		modelica_metatype	_c2
	)

Definition at line 16683 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_classNameGreater(threadData, _c1, _c2);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_crefEqual()

modelica_metatype boxptr_Absyn_crefEqual	(	threadData_t *	threadData,
		modelica_metatype	_iCr1,
		modelica_metatype	_iCr2
	)

Definition at line 10104 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_metatype out_outBoolean;
  _outBoolean = omc_Absyn_crefEqual(threadData, _iCr1, _iCr2);
  out_outBoolean = mmc_mk_icon(_outBoolean);
  return out_outBoolean;
}

Here is the call graph for this function:

boxptr_Absyn_crefEqualNoSubs()

modelica_metatype boxptr_Absyn_crefEqualNoSubs	(	threadData_t *	threadData,
		modelica_metatype	_cr1,
		modelica_metatype	_cr2
	)

Definition at line 9826 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_metatype out_outBoolean;
  _outBoolean = omc_Absyn_crefEqualNoSubs(threadData, _cr1, _cr2);
  out_outBoolean = mmc_mk_icon(_outBoolean);
  return out_outBoolean;
}

Here is the call graph for this function:

boxptr_Absyn_crefFirstEqual()

modelica_metatype boxptr_Absyn_crefFirstEqual	(	threadData_t *	threadData,
		modelica_metatype	_iCr1,
		modelica_metatype	_iCr2
	)

Definition at line 9943 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_metatype out_outBoolean;
  _outBoolean = omc_Absyn_crefFirstEqual(threadData, _iCr1, _iCr2);
  out_outBoolean = mmc_mk_icon(_outBoolean);
  return out_outBoolean;
}

Here is the call graph for this function:

boxptr_Absyn_crefHasSubscripts()

modelica_metatype boxptr_Absyn_crefHasSubscripts	(	threadData_t *	threadData,
		modelica_metatype	_cref
	)

Definition at line 11353 of file Absyn.c.

{
  modelica_boolean _hasSubscripts;
  modelica_metatype out_hasSubscripts;
  _hasSubscripts = omc_Absyn_crefHasSubscripts(threadData, _cref);
  out_hasSubscripts = mmc_mk_icon(_hasSubscripts);
  return out_hasSubscripts;
}

Here is the call graph for this function:

boxptr_Absyn_crefIsFullyQualified()

modelica_metatype boxptr_Absyn_crefIsFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 10649 of file Absyn.c.

{
  modelica_boolean _outIsFullyQualified;
  modelica_metatype out_outIsFullyQualified;
  _outIsFullyQualified = omc_Absyn_crefIsFullyQualified(threadData, _inCref);
  out_outIsFullyQualified = mmc_mk_icon(_outIsFullyQualified);
  return out_outIsFullyQualified;
}

Here is the call graph for this function:

boxptr_Absyn_crefIsIdent()

modelica_metatype boxptr_Absyn_crefIsIdent	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11633 of file Absyn.c.

{
  modelica_boolean _outIsIdent;
  modelica_metatype out_outIsIdent;
  _outIsIdent = omc_Absyn_crefIsIdent(threadData, _inComponentRef);
  out_outIsIdent = mmc_mk_icon(_outIsIdent);
  return out_outIsIdent;
}

Here is the call graph for this function:

boxptr_Absyn_crefIsQual()

modelica_metatype boxptr_Absyn_crefIsQual	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11575 of file Absyn.c.

{
  modelica_boolean _outIsQual;
  modelica_metatype out_outIsQual;
  _outIsQual = omc_Absyn_crefIsQual(threadData, _inComponentRef);
  out_outIsQual = mmc_mk_icon(_outIsQual);
  return out_outIsQual;
}

Here is the call graph for this function:

boxptr_Absyn_crefPrefixOf()

modelica_metatype boxptr_Absyn_crefPrefixOf	(	threadData_t *	threadData,
		modelica_metatype	_prefixCr,
		modelica_metatype	_cr
	)

Definition at line 14538 of file Absyn.c.

{
  modelica_boolean _out;
  modelica_metatype out_out;
  _out = omc_Absyn_crefPrefixOf(threadData, _prefixCr, _cr);
  out_out = mmc_mk_icon(_out);
  return out_out;
}

Here is the call graph for this function:

boxptr_Absyn_directionEqual()

modelica_metatype boxptr_Absyn_directionEqual	(	threadData_t *	threadData,
		modelica_metatype	_inDirection1,
		modelica_metatype	_inDirection2
	)

Definition at line 6203 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype out_outEqual;
  _outEqual = omc_Absyn_directionEqual(threadData, _inDirection1, _inDirection2);
  out_outEqual = mmc_mk_icon(_outEqual);
  return out_outEqual;
}

Here is the call graph for this function:

boxptr_Absyn_eachEqual()

modelica_metatype boxptr_Absyn_eachEqual	(	threadData_t *	threadData,
		modelica_metatype	_each1,
		modelica_metatype	_each2
	)

Definition at line 9480 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_metatype out_equal;
  _equal = omc_Absyn_eachEqual(threadData, _each1, _each2);
  out_equal = mmc_mk_icon(_equal);
  return out_equal;
}

Here is the call graph for this function:

boxptr_Absyn_elementArgEqualName()

modelica_metatype boxptr_Absyn_elementArgEqualName	(	threadData_t *	threadData,
		modelica_metatype	_inArg1,
		modelica_metatype	_inArg2
	)

Definition at line 2192 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype out_outEqual;
  _outEqual = omc_Absyn_elementArgEqualName(threadData, _inArg1, _inArg2);
  out_outEqual = mmc_mk_icon(_outEqual);
  return out_outEqual;
}

Here is the call graph for this function:

boxptr_Absyn_expContainsInitial()

modelica_metatype boxptr_Absyn_expContainsInitial	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 5269 of file Absyn.c.

{
  modelica_boolean _hasInitial;
  modelica_metatype out_hasInitial;
  _hasInitial = omc_Absyn_expContainsInitial(threadData, _inExp);
  out_hasInitial = mmc_mk_icon(_hasInitial);
  return out_hasInitial;
}

Here is the call graph for this function:

boxptr_Absyn_expEqual()

modelica_metatype boxptr_Absyn_expEqual	(	threadData_t *	threadData,
		modelica_metatype	_exp1,
		modelica_metatype	_exp2
	)

Definition at line 9577 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_metatype out_equal;
  _equal = omc_Absyn_expEqual(threadData, _exp1, _exp2);
  out_equal = mmc_mk_icon(_equal);
  return out_equal;
}

Here is the call graph for this function:

boxptr_Absyn_filterAnnotationItem()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_filterAnnotationItem	(	threadData_t *	threadData,
		modelica_metatype	_elt
	)

Definition at line 5605 of file Absyn.c.

{
  modelica_boolean _outB;
  modelica_metatype out_outB;
  _outB = omc_Absyn_filterAnnotationItem(threadData, _elt);
  out_outB = mmc_mk_icon(_outB);
  return out_outB;
}

Here is the call graph for this function:

boxptr_Absyn_functionArgsEqual()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_functionArgsEqual	(	threadData_t *	threadData,
		modelica_metatype	_args1,
		modelica_metatype	_args2
	)

Definition at line 9412 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_metatype out_equal;
  _equal = omc_Absyn_functionArgsEqual(threadData, _args1, _args2);
  out_equal = mmc_mk_icon(_equal);
  return out_equal;
}

Here is the call graph for this function:

boxptr_Absyn_getCrefFromExp()

modelica_metatype boxptr_Absyn_getCrefFromExp	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_includeSubs,
		modelica_metatype	_includeFunctions
	)

Definition at line 13734 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype _outComponentRefLst = NULL;
  tmp1 = mmc_unbox_integer(_includeSubs);
  tmp2 = mmc_unbox_integer(_includeFunctions);
  _outComponentRefLst = omc_Absyn_getCrefFromExp(threadData, _inExp, tmp1, tmp2);
  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
  return _outComponentRefLst;
}

Here is the call graph for this function:

boxptr_Absyn_getCrefFromFarg()

modelica_metatype boxptr_Absyn_getCrefFromFarg	(	threadData_t *	threadData,
		modelica_metatype	_inFunctionArgs,
		modelica_metatype	_includeSubs,
		modelica_metatype	_includeFunctions
	)

Definition at line 13185 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype _outComponentRefLst = NULL;
  tmp1 = mmc_unbox_integer(_includeSubs);
  tmp2 = mmc_unbox_integer(_includeFunctions);
  _outComponentRefLst = omc_Absyn_getCrefFromFarg(threadData, _inFunctionArgs, tmp1, tmp2);
  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
  return _outComponentRefLst;
}

Here is the call graph for this function:

boxptr_Absyn_getCrefFromNarg()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_getCrefFromNarg	(	threadData_t *	threadData,
		modelica_metatype	_inNamedArg,
		modelica_metatype	_includeSubs,
		modelica_metatype	_includeFunctions
	)

Definition at line 12931 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype _outComponentRefLst = NULL;
  tmp1 = mmc_unbox_integer(_includeSubs);
  tmp2 = mmc_unbox_integer(_includeFunctions);
  _outComponentRefLst = omc_Absyn_getCrefFromNarg(threadData, _inNamedArg, tmp1, tmp2);
  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
  return _outComponentRefLst;
}

Here is the call graph for this function:

boxptr_Absyn_getCrefsFromSubs()

modelica_metatype boxptr_Absyn_getCrefsFromSubs	(	threadData_t *	threadData,
		modelica_metatype	_isubs,
		modelica_metatype	_includeSubs,
		modelica_metatype	_includeFunctions
	)

Definition at line 13830 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype _crefs = NULL;
  tmp1 = mmc_unbox_integer(_includeSubs);
  tmp2 = mmc_unbox_integer(_includeFunctions);
  _crefs = omc_Absyn_getCrefsFromSubs(threadData, _isubs, tmp1, tmp2);
  /* skip box _crefs; list<Absyn.ComponentRef> */
  return _crefs;
}

Here is the call graph for this function:

boxptr_Absyn_getExpsFromArrayDim()

modelica_metatype boxptr_Absyn_getExpsFromArrayDim	(	threadData_t *	threadData,
		modelica_metatype	_inAd,
		modelica_metatype *	out_outExps
	)

Definition at line 6615 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype out_hasUnknownDimensions;
  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim(threadData, _inAd, out_outExps);
  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
  /* skip box _outExps; list<Absyn.Exp> */
  return out_hasUnknownDimensions;
}

Here is the call graph for this function:

boxptr_Absyn_getExpsFromArrayDim__tail()

modelica_metatype boxptr_Absyn_getExpsFromArrayDim__tail	(	threadData_t *	threadData,
		modelica_metatype	_inAd,
		modelica_metatype	_inAccumulator,
		modelica_metatype *	out_outExps
	)

Definition at line 6513 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype out_hasUnknownDimensions;
  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim__tail(threadData, _inAd, _inAccumulator, out_outExps);
  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
  /* skip box _outExps; list<Absyn.Exp> */
  return out_hasUnknownDimensions;
}

Here is the call graph for this function:

boxptr_Absyn_getExpsFromArrayDimOpt()

modelica_metatype boxptr_Absyn_getExpsFromArrayDimOpt	(	threadData_t *	threadData,
		modelica_metatype	_inAdO,
		modelica_metatype *	out_outExps
	)

Definition at line 6588 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype out_hasUnknownDimensions;
  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDimOpt(threadData, _inAdO, out_outExps);
  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
  /* skip box _outExps; list<Absyn.Exp> */
  return out_hasUnknownDimensions;
}

Here is the call graph for this function:

boxptr_Absyn_getSubsFromCref()

modelica_metatype boxptr_Absyn_getSubsFromCref	(	threadData_t *	threadData,
		modelica_metatype	_cr,
		modelica_metatype	_includeSubs,
		modelica_metatype	_includeFunctions
	)

Definition at line 11243 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype _subscripts = NULL;
  tmp1 = mmc_unbox_integer(_includeSubs);
  tmp2 = mmc_unbox_integer(_includeFunctions);
  _subscripts = omc_Absyn_getSubsFromCref(threadData, _cr, tmp1, tmp2);
  /* skip box _subscripts; list<Absyn.Subscript> */
  return _subscripts;
}

Here is the call graph for this function:

boxptr_Absyn_importEqual()

modelica_metatype boxptr_Absyn_importEqual	(	threadData_t *	threadData,
		modelica_metatype	_im1,
		modelica_metatype	_im2
	)

Definition at line 8273 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_metatype out_outBoolean;
  _outBoolean = omc_Absyn_importEqual(threadData, _im1, _im2);
  out_outBoolean = mmc_mk_icon(_outBoolean);
  return out_outBoolean;
}

Here is the call graph for this function:

boxptr_Absyn_innerOuterEqual()

modelica_metatype boxptr_Absyn_innerOuterEqual	(	threadData_t *	threadData,
		modelica_metatype	_io1,
		modelica_metatype	_io2
	)

Definition at line 8463 of file Absyn.c.

{
  modelica_boolean _res;
  modelica_metatype out_res;
  _res = omc_Absyn_innerOuterEqual(threadData, _io1, _io2);
  out_res = mmc_mk_icon(_res);
  return out_res;
}

Here is the call graph for this function:

boxptr_Absyn_isAlgorithmItem()

modelica_metatype boxptr_Absyn_isAlgorithmItem	(	threadData_t *	threadData,
		modelica_metatype	_inAlg
	)

Definition at line 868 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_metatype out_outIsClass;
  _outIsClass = omc_Absyn_isAlgorithmItem(threadData, _inAlg);
  out_outIsClass = mmc_mk_icon(_outIsClass);
  return out_outIsClass;
}

Here is the call graph for this function:

boxptr_Absyn_isClassdef()

modelica_metatype boxptr_Absyn_isClassdef	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 18054 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_isClassdef(threadData, _inElement);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_isClassNamed()

modelica_metatype boxptr_Absyn_isClassNamed	(	threadData_t *	threadData,
		modelica_metatype	_inName,
		modelica_metatype	_inClass
	)

Definition at line 18174 of file Absyn.c.

{
  modelica_boolean _outIsNamed;
  modelica_metatype out_outIsNamed;
  _outIsNamed = omc_Absyn_isClassNamed(threadData, _inName, _inClass);
  out_outIsNamed = mmc_mk_icon(_outIsNamed);
  return out_outIsNamed;
}

Here is the call graph for this function:

boxptr_Absyn_isCref()

modelica_metatype boxptr_Absyn_isCref	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 6855 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_isCref(threadData, _exp);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_isDerCref()

modelica_metatype boxptr_Absyn_isDerCref	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 6739 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_isDerCref(threadData, _exp);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_isElementItem()

modelica_metatype boxptr_Absyn_isElementItem	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 926 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_metatype out_outIsClass;
  _outIsClass = omc_Absyn_isElementItem(threadData, _inElement);
  out_outIsClass = mmc_mk_icon(_outIsClass);
  return out_outIsClass;
}

Here is the call graph for this function:

boxptr_Absyn_isElementItemClass()

modelica_metatype boxptr_Absyn_isElementItemClass	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 989 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_metatype out_outIsClass;
  _outIsClass = omc_Absyn_isElementItemClass(threadData, _inElement);
  out_outIsClass = mmc_mk_icon(_outIsClass);
  return out_outIsClass;
}

Here is the call graph for this function:

boxptr_Absyn_isElementItemClassNamed()

modelica_metatype boxptr_Absyn_isElementItemClassNamed	(	threadData_t *	threadData,
		modelica_metatype	_inName,
		modelica_metatype	_inElement
	)

Definition at line 810 of file Absyn.c.

{
  modelica_boolean _outIsNamed;
  modelica_metatype out_outIsNamed;
  _outIsNamed = omc_Absyn_isElementItemClassNamed(threadData, _inName, _inElement);
  out_outIsNamed = mmc_mk_icon(_outIsNamed);
  return out_outIsNamed;
}

Here is the call graph for this function:

boxptr_Absyn_isEmptyClassPart()

modelica_metatype boxptr_Absyn_isEmptyClassPart	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart
	)

Definition at line 743 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_metatype out_outIsEmpty;
  _outIsEmpty = omc_Absyn_isEmptyClassPart(threadData, _inClassPart);
  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
  return out_outIsEmpty;
}

Here is the call graph for this function:

boxptr_Absyn_isEmptyMod()

modelica_metatype boxptr_Absyn_isEmptyMod	(	threadData_t *	threadData,
		modelica_metatype	_inMod
	)

Definition at line 2392 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_metatype out_outIsEmpty;
  _outIsEmpty = omc_Absyn_isEmptyMod(threadData, _inMod);
  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
  return out_outIsEmpty;
}

Here is the call graph for this function:

boxptr_Absyn_isEmptySubMod()

modelica_metatype boxptr_Absyn_isEmptySubMod	(	threadData_t *	threadData,
		modelica_metatype	_inSubMod
	)

Definition at line 2315 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_metatype out_outIsEmpty;
  _outIsEmpty = omc_Absyn_isEmptySubMod(threadData, _inSubMod);
  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
  return out_outIsEmpty;
}

Here is the call graph for this function:

boxptr_Absyn_isExternalPart()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isExternalPart	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart
	)

Definition at line 5518 of file Absyn.c.

{
  modelica_boolean _outFound;
  modelica_metatype out_outFound;
  _outFound = omc_Absyn_isExternalPart(threadData, _inClassPart);
  out_outFound = mmc_mk_icon(_outFound);
  return out_outFound;
}

Here is the call graph for this function:

boxptr_Absyn_isFieldEqual()

modelica_metatype boxptr_Absyn_isFieldEqual	(	threadData_t *	threadData,
		modelica_metatype	_isField1,
		modelica_metatype	_isField2
	)

Definition at line 6117 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype out_outEqual;
  _outEqual = omc_Absyn_isFieldEqual(threadData, _isField1, _isField2);
  out_outEqual = mmc_mk_icon(_outEqual);
  return out_outEqual;
}

Here is the call graph for this function:

boxptr_Absyn_isFunctionRestriction()

modelica_metatype boxptr_Absyn_isFunctionRestriction	(	threadData_t *	threadData,
		modelica_metatype	_inRestriction
	)

Definition at line 9635 of file Absyn.c.

{
  modelica_boolean _outIsFunction;
  modelica_metatype out_outIsFunction;
  _outIsFunction = omc_Absyn_isFunctionRestriction(threadData, _inRestriction);
  out_outIsFunction = mmc_mk_icon(_outIsFunction);
  return out_outIsFunction;
}

Here is the call graph for this function:

boxptr_Absyn_isInitial()

modelica_metatype boxptr_Absyn_isInitial	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 5104 of file Absyn.c.

{
  modelica_boolean _hasReinit;
  modelica_metatype out_hasReinit;
  _hasReinit = omc_Absyn_isInitial(threadData, _inExp);
  out_hasReinit = mmc_mk_icon(_hasReinit);
  return out_hasReinit;
}

Here is the call graph for this function:

boxptr_Absyn_isInitialTraverseHelper()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isInitialTraverseHelper	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inBool,
		modelica_metatype *	out_outBool
	)

Definition at line 5191 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_boolean _outBool;
  modelica_metatype _outExp = NULL;
  tmp1 = mmc_unbox_integer(_inBool);
  _outExp = omc_Absyn_isInitialTraverseHelper(threadData, _inExp, tmp1, &_outBool);
  /* skip box _outExp; Absyn.Exp */
  if (out_outBool) { *out_outBool = mmc_mk_icon(_outBool); }
  return _outExp;
}

Here is the call graph for this function:

boxptr_Absyn_isInner()

modelica_metatype boxptr_Absyn_isInner	(	threadData_t *	threadData,
		modelica_metatype	_io
	)

Definition at line 8755 of file Absyn.c.

{
  modelica_boolean _isItAnInner;
  modelica_metatype out_isItAnInner;
  _isItAnInner = omc_Absyn_isInner(threadData, _io);
  out_isItAnInner = mmc_mk_icon(_isItAnInner);
  return out_isItAnInner;
}

Here is the call graph for this function:

boxptr_Absyn_isInnerOuter()

modelica_metatype boxptr_Absyn_isInnerOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8577 of file Absyn.c.

{
  modelica_boolean _outIsInnerOuter;
  modelica_metatype out_outIsInnerOuter;
  _outIsInnerOuter = omc_Absyn_isInnerOuter(threadData, _inIO);
  out_outIsInnerOuter = mmc_mk_icon(_outIsInnerOuter);
  return out_outIsInnerOuter;
}

Here is the call graph for this function:

boxptr_Absyn_isInput()

modelica_metatype boxptr_Absyn_isInput	(	threadData_t *	threadData,
		modelica_metatype	_inDirection
	)

Definition at line 6331 of file Absyn.c.

{
  modelica_boolean _outIsInput;
  modelica_metatype out_outIsInput;
  _outIsInput = omc_Absyn_isInput(threadData, _inDirection);
  out_outIsInput = mmc_mk_icon(_outIsInput);
  return out_outIsInput;
}

Here is the call graph for this function:

boxptr_Absyn_isInputOrOutput()

modelica_metatype boxptr_Absyn_isInputOrOutput	(	threadData_t *	threadData,
		modelica_metatype	_direction
	)

Definition at line 6402 of file Absyn.c.

{
  modelica_boolean _isIorO;
  modelica_metatype out_isIorO;
  _isIorO = omc_Absyn_isInputOrOutput(threadData, _direction);
  out_isIorO = mmc_mk_icon(_isIorO);
  return out_isIorO;
}

Here is the call graph for this function:

boxptr_Absyn_isInvariantExpNoTraverse()

modelica_metatype boxptr_Absyn_isInvariantExpNoTraverse	(	threadData_t *	threadData,
		modelica_metatype _	$in_e,
		modelica_metatype _	$in_b,
		modelica_metatype *	out_b
	)

Definition at line 620 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_boolean _b;
  modelica_metatype _e = NULL;
  tmp1 = mmc_unbox_integer(_$in_b);
  _e = omc_Absyn_isInvariantExpNoTraverse(threadData, _$in_e, tmp1, &_b);
  /* skip box _e; Absyn.Exp */
  if (out_b) { *out_b = mmc_mk_icon(_b); }
  return _e;
}

Here is the call graph for this function:

boxptr_Absyn_isModificationOfPath()

modelica_metatype boxptr_Absyn_isModificationOfPath	(	threadData_t *	threadData,
		modelica_metatype	_mod,
		modelica_metatype	_path
	)

Definition at line 4638 of file Absyn.c.

{
  modelica_boolean _yes;
  modelica_metatype out_yes;
  _yes = omc_Absyn_isModificationOfPath(threadData, _mod, _path);
  out_yes = mmc_mk_icon(_yes);
  return out_yes;
}

Here is the call graph for this function:

boxptr_Absyn_isNotInnerOuter()

modelica_metatype boxptr_Absyn_isNotInnerOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8520 of file Absyn.c.

{
  modelica_boolean _outIsNotInnerOuter;
  modelica_metatype out_outIsNotInnerOuter;
  _outIsNotInnerOuter = omc_Absyn_isNotInnerOuter(threadData, _inIO);
  out_outIsNotInnerOuter = mmc_mk_icon(_outIsNotInnerOuter);
  return out_outIsNotInnerOuter;
}

Here is the call graph for this function:

boxptr_Absyn_isOnlyInner()

modelica_metatype boxptr_Absyn_isOnlyInner	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8691 of file Absyn.c.

{
  modelica_boolean _outOnlyInner;
  modelica_metatype out_outOnlyInner;
  _outOnlyInner = omc_Absyn_isOnlyInner(threadData, _inIO);
  out_outOnlyInner = mmc_mk_icon(_outOnlyInner);
  return out_outOnlyInner;
}

Here is the call graph for this function:

boxptr_Absyn_isOnlyOuter()

modelica_metatype boxptr_Absyn_isOnlyOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8634 of file Absyn.c.

{
  modelica_boolean _outOnlyOuter;
  modelica_metatype out_outOnlyOuter;
  _outOnlyOuter = omc_Absyn_isOnlyOuter(threadData, _inIO);
  out_outOnlyOuter = mmc_mk_icon(_outOnlyOuter);
  return out_outOnlyOuter;
}

Here is the call graph for this function:

boxptr_Absyn_isOuter()

modelica_metatype boxptr_Absyn_isOuter	(	threadData_t *	threadData,
		modelica_metatype	_io
	)

Definition at line 8819 of file Absyn.c.

{
  modelica_boolean _isItAnOuter;
  modelica_metatype out_isItAnOuter;
  _isItAnOuter = omc_Absyn_isOuter(threadData, _io);
  out_isItAnOuter = mmc_mk_icon(_isItAnOuter);
  return out_isItAnOuter;
}

Here is the call graph for this function:

boxptr_Absyn_isOutput()

modelica_metatype boxptr_Absyn_isOutput	(	threadData_t *	threadData,
		modelica_metatype	_inDirection
	)

Definition at line 6267 of file Absyn.c.

{
  modelica_boolean _outIsOutput;
  modelica_metatype out_outIsOutput;
  _outIsOutput = omc_Absyn_isOutput(threadData, _inDirection);
  out_outIsOutput = mmc_mk_icon(_outIsOutput);
  return out_outIsOutput;
}

Here is the call graph for this function:

boxptr_Absyn_isPackageRestriction()

modelica_metatype boxptr_Absyn_isPackageRestriction	(	threadData_t *	threadData,
		modelica_metatype	_inRestriction
	)

Definition at line 9692 of file Absyn.c.

{
  modelica_boolean _outIsPackage;
  modelica_metatype out_outIsPackage;
  _outIsPackage = omc_Absyn_isPackageRestriction(threadData, _inRestriction);
  out_outIsPackage = mmc_mk_icon(_outIsPackage);
  return out_outIsPackage;
}

Here is the call graph for this function:

boxptr_Absyn_isParts()

modelica_metatype boxptr_Absyn_isParts	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5461 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_isParts(threadData, _cl);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_isTuple()

modelica_metatype boxptr_Absyn_isTuple	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 6797 of file Absyn.c.

{
  modelica_boolean _outIsTuple;
  modelica_metatype out_outIsTuple;
  _outIsTuple = omc_Absyn_isTuple(threadData, _inExp);
  out_outIsTuple = mmc_mk_icon(_outIsTuple);
  return out_outIsTuple;
}

Here is the call graph for this function:

boxptr_Absyn_iteratorIndexedCrefsEqual()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_iteratorIndexedCrefsEqual	(	threadData_t *	threadData,
		modelica_metatype	_inCref1,
		modelica_metatype	_inCref2
	)

Definition at line 9239 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype out_outEqual;
  _outEqual = omc_Absyn_iteratorIndexedCrefsEqual(threadData, _inCref1, _inCref2);
  out_outEqual = mmc_mk_icon(_outEqual);
  return out_outEqual;
}

Here is the call graph for this function:

boxptr_Absyn_onlyLiteralsInAnnotationMod()

modelica_metatype boxptr_Absyn_onlyLiteralsInAnnotationMod	(	threadData_t *	threadData,
		modelica_metatype	_inMod
	)

Definition at line 8050 of file Absyn.c.

{
  modelica_boolean _onlyLiterals;
  modelica_metatype out_onlyLiterals;
  _onlyLiterals = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _inMod);
  out_onlyLiterals = mmc_mk_icon(_onlyLiterals);
  return out_onlyLiterals;
}

Here is the call graph for this function:

boxptr_Absyn_onlyLiteralsInEqMod()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_onlyLiteralsInEqMod	(	threadData_t *	threadData,
		modelica_metatype	_eqMod
	)

Definition at line 7917 of file Absyn.c.

{
  modelica_boolean _onlyLiterals;
  modelica_metatype out_onlyLiterals;
  _onlyLiterals = omc_Absyn_onlyLiteralsInEqMod(threadData, _eqMod);
  out_onlyLiterals = mmc_mk_icon(_onlyLiterals);
  return out_onlyLiterals;
}

Here is the call graph for this function:

boxptr_Absyn_opEqual()

modelica_metatype boxptr_Absyn_opEqual	(	threadData_t *	threadData,
		modelica_metatype	_op1,
		modelica_metatype	_op2
	)

Definition at line 3452 of file Absyn.c.

{
  modelica_boolean _isEqual;
  modelica_metatype out_isEqual;
  _isEqual = omc_Absyn_opEqual(threadData, _op1, _op2);
  out_isEqual = mmc_mk_icon(_isEqual);
  return out_isEqual;
}

Here is the call graph for this function:

boxptr_Absyn_opIsElementWise()

modelica_metatype boxptr_Absyn_opIsElementWise	(	threadData_t *	threadData,
		modelica_metatype	_op
	)

Definition at line 3431 of file Absyn.c.

{
  modelica_boolean _isElementWise;
  modelica_metatype out_isElementWise;
  _isElementWise = omc_Absyn_opIsElementWise(threadData, _op);
  out_isElementWise = mmc_mk_icon(_isElementWise);
  return out_isElementWise;
}

Here is the call graph for this function:

boxptr_Absyn_optArrayDimEqual()

modelica_metatype boxptr_Absyn_optArrayDimEqual	(	threadData_t *	threadData,
		modelica_metatype	_oad1,
		modelica_metatype	_oad2
	)

Definition at line 17458 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_optMsg()

modelica_metatype boxptr_Absyn_optMsg	(	threadData_t *	threadData,
		modelica_metatype	_inShowMessage,
		modelica_metatype	_inInfo
	)

Definition at line 2124 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_metatype _outMsg = NULL;
  tmp1 = mmc_unbox_integer(_inShowMessage);
  _outMsg = omc_Absyn_optMsg(threadData, tmp1, _inInfo);
  /* skip box _outMsg; Absyn.Msg */
  return _outMsg;
}

Here is the call graph for this function:

boxptr_Absyn_pathCompare()

modelica_metatype boxptr_Absyn_pathCompare	(	threadData_t *	threadData,
		modelica_metatype	_ip1,
		modelica_metatype	_ip2
	)

Definition at line 16662 of file Absyn.c.

{
  modelica_integer _o;
  modelica_metatype out_o;
  _o = omc_Absyn_pathCompare(threadData, _ip1, _ip2);
  out_o = mmc_mk_icon(_o);
  return out_o;
}

Here is the call graph for this function:

boxptr_Absyn_pathCompareNoQual()

modelica_metatype boxptr_Absyn_pathCompareNoQual	(	threadData_t *	threadData,
		modelica_metatype	_ip1,
		modelica_metatype	_ip2
	)

Definition at line 16497 of file Absyn.c.

{
  modelica_integer _o;
  modelica_metatype out_o;
  _o = omc_Absyn_pathCompareNoQual(threadData, _ip1, _ip2);
  out_o = mmc_mk_icon(_o);
  return out_o;
}

Here is the call graph for this function:

boxptr_Absyn_pathContains()

modelica_metatype boxptr_Absyn_pathContains	(	threadData_t *	threadData,
		modelica_metatype	_fullPath,
		modelica_metatype	_pathId
	)

Definition at line 14129 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_pathContains(threadData, _fullPath, _pathId);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_pathContainsString()

modelica_metatype boxptr_Absyn_pathContainsString	(	threadData_t *	threadData,
		modelica_metatype	_p1,
		modelica_metatype	_str
	)

Definition at line 14031 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_pathContainsString(threadData, _p1, _str);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

boxptr_Absyn_pathEqual()

modelica_metatype boxptr_Absyn_pathEqual	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 17759 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_metatype out_outBoolean;
  _outBoolean = omc_Absyn_pathEqual(threadData, _inPath1, _inPath2);
  out_outBoolean = mmc_mk_icon(_outBoolean);
  return out_outBoolean;
}

Here is the call graph for this function:

boxptr_Absyn_pathGe()

modelica_metatype boxptr_Absyn_pathGe	(	threadData_t *	threadData,
		modelica_metatype	_path1,
		modelica_metatype	_path2
	)

Definition at line 6028 of file Absyn.c.

{
  modelica_boolean _ge;
  modelica_metatype out_ge;
  _ge = omc_Absyn_pathGe(threadData, _path1, _path2);
  out_ge = mmc_mk_icon(_ge);
  return out_ge;
}

Here is the call graph for this function:

boxptr_Absyn_pathHashMod()

modelica_metatype boxptr_Absyn_pathHashMod	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_mod
	)

Definition at line 16357 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer _hash;
  modelica_metatype out_hash;
  tmp1 = mmc_unbox_integer(_mod);
  _hash = omc_Absyn_pathHashMod(threadData, _path, tmp1);
  out_hash = mmc_mk_icon(_hash);
  return out_hash;
}

Here is the call graph for this function:

boxptr_Absyn_pathHashModWork()

modelica_metatype boxptr_Absyn_pathHashModWork	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_acc
	)

Definition at line 16334 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer _hash;
  modelica_metatype out_hash;
  tmp1 = mmc_unbox_integer(_acc);
  _hash = omc_Absyn_pathHashModWork(threadData, _path, tmp1);
  out_hash = mmc_mk_icon(_hash);
  return out_hash;
}

Here is the call graph for this function:

boxptr_Absyn_pathIsFullyQualified()

modelica_metatype boxptr_Absyn_pathIsFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7524 of file Absyn.c.

{
  modelica_boolean _outIsQualified;
  modelica_metatype out_outIsQualified;
  _outIsQualified = omc_Absyn_pathIsFullyQualified(threadData, _inPath);
  out_outIsQualified = mmc_mk_icon(_outIsQualified);
  return out_outIsQualified;
}

Here is the call graph for this function:

boxptr_Absyn_pathIsIdent()

modelica_metatype boxptr_Absyn_pathIsIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7466 of file Absyn.c.

{
  modelica_boolean _outIsIdent;
  modelica_metatype out_outIsIdent;
  _outIsIdent = omc_Absyn_pathIsIdent(threadData, _inPath);
  out_outIsIdent = mmc_mk_icon(_outIsIdent);
  return out_outIsIdent;
}

Here is the call graph for this function:

boxptr_Absyn_pathIsQual()

modelica_metatype boxptr_Absyn_pathIsQual	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7408 of file Absyn.c.

{
  modelica_boolean _outIsQual;
  modelica_metatype out_outIsQual;
  _outIsQual = omc_Absyn_pathIsQual(threadData, _inPath);
  out_outIsQual = mmc_mk_icon(_outIsQual);
  return out_outIsQual;
}

Here is the call graph for this function:

boxptr_Absyn_pathLt()

modelica_metatype boxptr_Absyn_pathLt	(	threadData_t *	threadData,
		modelica_metatype	_path1,
		modelica_metatype	_path2
	)

Definition at line 6049 of file Absyn.c.

{
  modelica_boolean _lt;
  modelica_metatype out_lt;
  _lt = omc_Absyn_pathLt(threadData, _path1, _path2);
  out_lt = mmc_mk_icon(_lt);
  return out_lt;
}

Here is the call graph for this function:

boxptr_Absyn_pathPartCount()

modelica_metatype boxptr_Absyn_pathPartCount	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_partsAccum
	)

Definition at line 398 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer _parts;
  modelica_metatype out_parts;
  tmp1 = mmc_unbox_integer(_partsAccum);
  _parts = omc_Absyn_pathPartCount(threadData, _path, tmp1);
  out_parts = mmc_mk_icon(_parts);
  return out_parts;
}

Here is the call graph for this function:

boxptr_Absyn_pathPrefixOf()

modelica_metatype boxptr_Absyn_pathPrefixOf	(	threadData_t *	threadData,
		modelica_metatype	_prefixPath,
		modelica_metatype	_path
	)

Definition at line 14688 of file Absyn.c.

{
  modelica_boolean _isPrefix;
  modelica_metatype out_isPrefix;
  _isPrefix = omc_Absyn_pathPrefixOf(threadData, _prefixPath, _path);
  out_isPrefix = mmc_mk_icon(_isPrefix);
  return out_isPrefix;
}

Here is the call graph for this function:

boxptr_Absyn_pathString()

modelica_metatype boxptr_Absyn_pathString	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_delimiter,
		modelica_metatype	_usefq,
		modelica_metatype	_reverse
	)

Definition at line 17181 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_string _s = NULL;
  tmp1 = mmc_unbox_integer(_usefq);
  tmp2 = mmc_unbox_integer(_reverse);
  _s = omc_Absyn_pathString(threadData, _path, _delimiter, tmp1, tmp2);
  /* skip box _s; String */
  return _s;
}

Here is the call graph for this function:

boxptr_Absyn_pathStringNoQual()

modelica_metatype boxptr_Absyn_pathStringNoQual	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_delimiter,
		modelica_metatype	_usefq,
		modelica_metatype	_reverse
	)

Definition at line 16885 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_string _s = NULL;
  tmp1 = mmc_unbox_integer(_usefq);
  tmp2 = mmc_unbox_integer(_reverse);
  _s = omc_Absyn_pathStringNoQual(threadData, _path, _delimiter, tmp1, tmp2);
  /* skip box _s; String */
  return _s;
}

Here is the call graph for this function:

boxptr_Absyn_pathStringWork()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_pathStringWork	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_metatype	_len,
		modelica_metatype	_delimiter,
		modelica_metatype	_dlen,
		modelica_metatype	_reverse
	)

Definition at line 17006 of file Absyn.c.

{
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_integer tmp3;
  modelica_string _s = NULL;
  tmp1 = mmc_unbox_integer(_len);
  tmp2 = mmc_unbox_integer(_dlen);
  tmp3 = mmc_unbox_integer(_reverse);
  _s = omc_Absyn_pathStringWork(threadData, _inPath, tmp1, _delimiter, tmp2, tmp3);
  /* skip box _s; String */
  return _s;
}

Here is the call graph for this function:

boxptr_Absyn_pathSuffixOf()

modelica_metatype boxptr_Absyn_pathSuffixOf	(	threadData_t *	threadData,
		modelica_metatype	_suffix_path,
		modelica_metatype	_path
	)

Definition at line 15116 of file Absyn.c.

{
  modelica_boolean _res;
  modelica_metatype out_res;
  _res = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _path);
  out_res = mmc_mk_icon(_res);
  return out_res;
}

Here is the call graph for this function:

boxptr_Absyn_pathSuffixOfr()

modelica_metatype boxptr_Absyn_pathSuffixOfr	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_suffix_path
	)

Definition at line 15019 of file Absyn.c.

{
  modelica_boolean _res;
  modelica_metatype out_res;
  _res = omc_Absyn_pathSuffixOfr(threadData, _path, _suffix_path);
  out_res = mmc_mk_icon(_res);
  return out_res;
}

Here is the call graph for this function:

boxptr_Absyn_subscriptEqual()

modelica_metatype boxptr_Absyn_subscriptEqual	(	threadData_t *	threadData,
		modelica_metatype	_inSubscript1,
		modelica_metatype	_inSubscript2
	)

Definition at line 9922 of file Absyn.c.

{
  modelica_boolean _outIsEqual;
  modelica_metatype out_outIsEqual;
  _outIsEqual = omc_Absyn_subscriptEqual(threadData, _inSubscript1, _inSubscript2);
  out_outIsEqual = mmc_mk_icon(_outIsEqual);
  return out_outIsEqual;
}

Here is the call graph for this function:

boxptr_Absyn_subscriptsEqual()

modelica_metatype boxptr_Absyn_subscriptsEqual	(	threadData_t *	threadData,
		modelica_metatype	_inSubList1,
		modelica_metatype	_inSubList2
	)

Definition at line 9847 of file Absyn.c.

{
  modelica_boolean _outIsEqual;
  modelica_metatype out_outIsEqual;
  _outIsEqual = omc_Absyn_subscriptsEqual(threadData, _inSubList1, _inSubList2);
  out_outIsEqual = mmc_mk_icon(_outIsEqual);
  return out_outIsEqual;
}

Here is the call graph for this function:

boxptr_Absyn_traverseClassDef()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassDef	(	threadData_t *	threadData,
		modelica_metatype	_inClassDef,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 2483 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outClassDef = NULL;
  _outClassDef = omc_Absyn_traverseClassDef(threadData, _inClassDef, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outClassDef; Absyn.ClassDef */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outClassDef;
}

Here is the call graph for this function:

boxptr_Absyn_traverseClassPartComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassPartComponents	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 2909 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outClassPart = NULL;
  _outClassPart = omc_Absyn_traverseClassPartComponents(threadData, _inClassPart, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outClassPart; Absyn.ClassPart */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outClassPart;
}

Here is the call graph for this function:

boxptr_Absyn_traverseElementComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementComponents	(	threadData_t *	threadData,
		modelica_metatype	_inElement,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 2694 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outElement = NULL;
  _outElement = omc_Absyn_traverseElementComponents(threadData, _inElement, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outElement; Absyn.Element */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outElement;
}

Here is the call graph for this function:

boxptr_Absyn_traverseElementItemComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementItemComponents	(	threadData_t *	threadData,
		modelica_metatype	_inItem,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 2803 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outItem = NULL;
  _outItem = omc_Absyn_traverseElementItemComponents(threadData, _inItem, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outItem; Absyn.ElementItem */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outItem;
}

Here is the call graph for this function:

boxptr_Absyn_traverseElementSpecComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementSpecComponents	(	threadData_t *	threadData,
		modelica_metatype	_inSpec,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 2594 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outSpec = NULL;
  _outSpec = omc_Absyn_traverseElementSpecComponents(threadData, _inSpec, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outSpec; Absyn.ElementSpec */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outSpec;
}

Here is the call graph for this function:

boxptr_Absyn_traverseListGeneric()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseListGeneric	(	threadData_t *	threadData,
		modelica_metatype	_inList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_metatype *	out_outContinue
	)

Definition at line 3019 of file Absyn.c.

{
  modelica_boolean _outContinue;
  modelica_metatype _outList = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  _outList = omc_Absyn_traverseListGeneric(threadData, _inList, _inFunc, _inArg, out_outArg, &_outContinue);
  /* skip box _outList; list<polymorphic<T>> */
  /* skip box _outArg; polymorphic<ArgT> */
  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
  return _outList;
}

Here is the call graph for this function:

boxptr_Absyn_typeSpecEqual()

modelica_metatype boxptr_Absyn_typeSpecEqual	(	threadData_t *	threadData,
		modelica_metatype	_a,
		modelica_metatype	_b
	)

Definition at line 17606 of file Absyn.c.

{
  modelica_boolean _ob;
  modelica_metatype out_ob;
  _ob = omc_Absyn_typeSpecEqual(threadData, _a, _b);
  out_ob = mmc_mk_icon(_ob);
  return out_ob;
}

Here is the call graph for this function:

boxptr_Absyn_withinEqual()

modelica_metatype boxptr_Absyn_withinEqual	(	threadData_t *	threadData,
		modelica_metatype	_within1,
		modelica_metatype	_within2
	)

Definition at line 7350 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_metatype out_b;
  _b = omc_Absyn_withinEqual(threadData, _within1, _within2);
  out_b = mmc_mk_icon(_b);
  return out_b;
}

Here is the call graph for this function:

omc_Absyn_addSubscriptsLast()

DLLExport modelica_metatype omc_Absyn_addSubscriptsLast	(	threadData_t *	threadData,
		modelica_metatype	_icr,
		modelica_metatype	_i
	)

Definition at line 14777 of file Absyn.c.

{
  modelica_metatype _ocr = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14783 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _icr;
    {
      modelica_metatype _subs = NULL;
      modelica_string _id = NULL;
      modelica_metatype _cr = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _id = tmpMeta[1];
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, listAppend(_subs, _i));
#line 3216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 14805 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _id = tmpMeta[1];
          _subs = tmpMeta[2];
          _cr = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = omc_Absyn_addSubscriptsLast(threadData, _cr, _i);
#line 14819 OMC_FILE
#line 3221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _subs, _cr);
#line 3221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 14824 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3225 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = omc_Absyn_addSubscriptsLast(threadData, _cr, _i);
#line 14834 OMC_FILE
#line 3226 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr);
#line 14837 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _ocr = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _ocr;
}

Here is the caller graph for this function:

omc_Absyn_annotationToElementArgs()

DLLExport modelica_metatype omc_Absyn_annotationToElementArgs	(	threadData_t *	threadData,
		modelica_metatype	_ann
	)

Definition at line 4407 of file Absyn.c.

{
  modelica_metatype _args = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _ann;
#line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _args = tmpMeta[1];
#line 4421 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _args;
}

Here is the caller graph for this function:

omc_Absyn_canonIfExp()

DLLExport modelica_metatype omc_Absyn_canonIfExp	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 8060 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype tmpMeta[9] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8066 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inExp;
    {
      modelica_metatype _cond = NULL;
      modelica_metatype _tb = NULL;
      modelica_metatype _eb = NULL;
      modelica_metatype _ei_cond = NULL;
      modelica_metatype _ei_tb = NULL;
      modelica_metatype _e = NULL;
      modelica_metatype _eib = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          if (!listEmpty(tmpMeta[1])) goto tmp2_end;
          /* Pattern matching succeeded */
#line 4974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inExp;
#line 8090 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          if (listEmpty(tmpMeta[4])) goto tmp2_end;
          tmpMeta[5] = MMC_CAR(tmpMeta[4]);
          tmpMeta[6] = MMC_CDR(tmpMeta[4]);
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 1));
          tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          _cond = tmpMeta[1];
          _tb = tmpMeta[2];
          _eb = tmpMeta[3];
          _ei_cond = tmpMeta[7];
          _ei_tb = tmpMeta[8];
          _eib = tmpMeta[6];
          /* Pattern matching succeeded */
#line 4977 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _ei_cond, _ei_tb, _eb, _eib);
#line 4977 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e = omc_Absyn_canonIfExp(threadData, tmpMeta[1]);
#line 8115 OMC_FILE
#line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _cond, _tb, _e, tmpMeta[1]);
#line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 8122 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outExp = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outExp;
}

Here is the caller graph for this function:

omc_Absyn_classFilename()

DLLExport modelica_string omc_Absyn_classFilename	(	threadData_t *	threadData,
		modelica_metatype	_inClass
	)

Definition at line 10281 of file Absyn.c.

{
  modelica_string _outFilename = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inClass;
#line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 8));
#line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outFilename = tmpMeta[2];
#line 10297 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outFilename;
}

Here is the caller graph for this function:

omc_Absyn_className()

DLLExport modelica_metatype omc_Absyn_className	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 18184 of file Absyn.c.

{
  modelica_metatype _name = NULL;
  modelica_string _id = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _cl;
#line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _id = tmpMeta[1];
#line 18199 OMC_FILE

#line 2432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
#line 2432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[0];
#line 18205 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _name;
}

omc_Absyn_classNameCompare()

DLLExport modelica_integer omc_Absyn_classNameCompare	(	threadData_t *	threadData,
		modelica_metatype	_c1,
		modelica_metatype	_c2
	)

Definition at line 16693 of file Absyn.c.

{
  modelica_integer _o;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2745 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _o = stringCompare((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c1), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c2), 2))));
#line 16700 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the caller graph for this function:

omc_Absyn_classNameGreater()

DLLExport modelica_boolean omc_Absyn_classNameGreater	(	threadData_t *	threadData,
		modelica_metatype	_c1,
		modelica_metatype	_c2
	)

Definition at line 16672 of file Absyn.c.

{
  modelica_boolean _b;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2752 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _b = (stringCompare((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c1), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c2), 2)))) > ((modelica_integer) 0));
#line 16679 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the caller graph for this function:

omc_Absyn_componentName()

DLLExport modelica_string omc_Absyn_componentName	(	threadData_t *	threadData,
		modelica_metatype	_c
	)

Definition at line 5352 of file Absyn.c.

{
  modelica_string _name = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _c;
#line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[2];
#line 5368 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _name;
}

Here is the caller graph for this function:

omc_Absyn_crefEqual()

DLLExport modelica_boolean omc_Absyn_crefEqual	(	threadData_t *	threadData,
		modelica_metatype	_iCr1,
		modelica_metatype	_iCr2
	)

Definition at line 9953 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9960 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _iCr1;
    tmp4_2 = _iCr2;
    {
      modelica_string _id = NULL;
      modelica_string _id2 = NULL;
      modelica_metatype _ss1 = NULL;
      modelica_metatype _ss2 = NULL;
      modelica_metatype _cr1 = NULL;
      modelica_metatype _cr2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 4; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _id = tmpMeta[0];
          _ss1 = tmpMeta[1];
          _id2 = tmpMeta[2];
          _ss2 = tmpMeta[3];
          tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id, _id2));
#line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 10000 OMC_FILE

#line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = omc_Absyn_subscriptsEqual(threadData, _ss1, _ss2);
#line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_2;
#line 10008 OMC_FILE
#line 4517 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 10011 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_boolean tmp8;
          modelica_boolean tmp9;
          modelica_boolean tmp10;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
          _id = tmpMeta[0];
          _ss1 = tmpMeta[1];
          _cr1 = tmpMeta[2];
          _id2 = tmpMeta[3];
          _ss2 = tmpMeta[4];
          _cr2 = tmpMeta[5];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp8 = (stringEqual(_id, _id2));
#line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp8) goto goto_2;
#line 10039 OMC_FILE

#line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp9 = omc_Absyn_subscriptsEqual(threadData, _ss1, _ss2);
#line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp9) goto goto_2;
#line 10047 OMC_FILE

#line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp10 = omc_Absyn_crefEqual(threadData, _cr1, _cr2);
#line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp10) goto goto_2;
#line 10055 OMC_FILE
#line 4525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 10058 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _cr1 = tmpMeta[0];
          _cr2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefEqual(threadData, _cr1, _cr2);
#line 10071 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 10079 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 4) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _outBoolean = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outBoolean;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefEqualNoSubs()

DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs	(	threadData_t *	threadData,
		modelica_metatype	_cr1,
		modelica_metatype	_cr2
	)

Definition at line 9702 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9709 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _cr1;
    tmp4_2 = _cr2;
    {
      modelica_metatype _rest1 = NULL;
      modelica_metatype _rest2 = NULL;
      modelica_string _id = NULL;
      modelica_string _id2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 4; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _id = tmpMeta[0];
          _id2 = tmpMeta[1];
          tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id, _id2));
#line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 9743 OMC_FILE
#line 4586 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9746 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_boolean tmp7;
          modelica_boolean tmp8;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
          _id = tmpMeta[0];
          _rest1 = tmpMeta[1];
          _id2 = tmpMeta[2];
          _rest2 = tmpMeta[3];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = (stringEqual(_id, _id2));
#line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_2;
#line 9769 OMC_FILE

#line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp8 = omc_Absyn_crefEqualNoSubs(threadData, _rest1, _rest2);
#line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp8) goto goto_2;
#line 9777 OMC_FILE
#line 4592 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9780 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _rest1 = tmpMeta[0];
          _rest2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefEqualNoSubs(threadData, _rest1, _rest2);
#line 9793 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9801 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 4) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _outBoolean = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outBoolean;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefExp()

DLLExport modelica_metatype omc_Absyn_crefExp	(	threadData_t *	threadData,
		modelica_metatype	_cr
	)

Definition at line 17878 of file Absyn.c.

{
  modelica_metatype _exp = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _cr);
#line 2511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _exp = tmpMeta[0];
#line 17888 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _exp;
}

omc_Absyn_crefExplode()

DLLExport modelica_metatype omc_Absyn_crefExplode	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_metatype	_inAccum
	)

Definition at line 1999 of file Absyn.c.

{
  modelica_metatype _outCrefParts = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2005 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(omc_Absyn_crefFirstCref(threadData, _inCref), _inAccum);
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 4)));
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inAccum = tmpMeta[2];
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = tmpMeta[1];
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 2030 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
#line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 2044 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 6583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_inCref, _inAccum);
#line 6583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listReverse(tmpMeta[1]);
#line 2055 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCrefParts = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCrefParts;
}

Here is the caller graph for this function:

omc_Absyn_crefFirstCref()

DLLExport modelica_metatype omc_Absyn_crefFirstCref	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 10719 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10725 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 4363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 3))));
#line 4363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 10740 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
#line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 10754 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 4365 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inCref;
#line 10763 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

omc_Absyn_crefFirstEqual()

DLLExport modelica_boolean omc_Absyn_crefFirstEqual	(	threadData_t *	threadData,
		modelica_metatype	_iCr1,
		modelica_metatype	_iCr2
	)

Definition at line 9932 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4544 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outBoolean = (stringEqual(omc_Absyn_crefFirstIdent(threadData, _iCr1), omc_Absyn_crefFirstIdent(threadData, _iCr2)));
#line 9939 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outBoolean;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefFirstIdent()

DLLExport modelica_string omc_Absyn_crefFirstIdent	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 10840 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10846 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inCref;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          
          /* Pattern matching succeeded */
#line 4341 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
#line 10859 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 4342 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
#line 10867 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
#line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 10881 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

Here is the caller graph for this function:

omc_Absyn_crefFirstIdentNoSubs()

DLLExport modelica_string omc_Absyn_crefFirstIdentNoSubs	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 11643 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11650 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inCref;
    {
      modelica_string _id = NULL;
      modelica_metatype _cr = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (!listEmpty(tmpMeta[1])) goto tmp3_end;
          _id = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4135 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _id;
#line 11669 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (!listEmpty(tmpMeta[1])) goto tmp3_end;
          
          _id = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4136 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _id;
#line 11682 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _cr = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = _cr;
#line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11698 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

omc_Absyn_crefGetLastIdent()

DLLExport modelica_metatype omc_Absyn_crefGetLastIdent	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11091 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11097 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_metatype _cref = NULL;
      modelica_string _id = NULL;
      modelica_metatype _subs = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _id = tmpMeta[1];
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, _subs);
#line 4270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 11119 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cref;
#line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11135 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cref;
#line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11151 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

omc_Absyn_crefHasSubscripts()

DLLExport modelica_boolean omc_Absyn_crefHasSubscripts	(	threadData_t *	threadData,
		modelica_metatype	_cref
	)

Definition at line 11256 of file Absyn.c.

{
  modelica_boolean _hasSubscripts;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11263 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _cref;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 6; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (!listEmpty((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 3)))));
#line 11279 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 4)));
#line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11296 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 2)));
#line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11311 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 11319 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4224 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 11327 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          
          /* Pattern matching succeeded */
#line 4225 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 11335 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _hasSubscripts = tmp1;
  _return: OMC_LABEL_UNUSED
  return _hasSubscripts;
}

Here is the caller graph for this function:

omc_Absyn_crefIdent()

DLLExport modelica_string omc_Absyn_crefIdent	(	threadData_t *	threadData,
		modelica_metatype	_cr
	)

Definition at line 7599 of file Absyn.c.

{
  modelica_string _str = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _cr;
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) MMC_THROW_INTERNAL();
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (!listEmpty(tmpMeta[2])) MMC_THROW_INTERNAL();
#line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _str = tmpMeta[1];
#line 7619 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _str;
}

Here is the caller graph for this function:

omc_Absyn_crefInsertSubscriptLstLst()

DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inLst,
		modelica_metatype *	out_outLst
	)

Definition at line 6978 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outLst = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5262 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5262 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6989 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _inExp;
    tmp4_2 = _inLst;
    {
      modelica_metatype _cref = NULL;
      modelica_metatype _cref2 = NULL;
      modelica_metatype _subs = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _cref = tmpMeta[2];
          _subs = tmp4_2;
          /* Pattern matching succeeded */
#line 5269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
#line 7015 OMC_FILE
#line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _cref2);
#line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _subs;
#line 7022 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inLst;
#line 7032 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 2) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _outExp = tmpMeta[0+0];
  _outLst = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outLst) { *out_outLst = _outLst; }
  return _outExp;
}

Here is the call graph for this function:

omc_Absyn_crefInsertSubscriptLstLst2()

DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst2	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_metatype	_inSubs
	)

Definition at line 6865 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6871 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
    tmp3_1 = _inCref;
    tmp3_2 = _inSubs;
    {
      modelica_metatype _cref = NULL;
      modelica_metatype _cref2 = NULL;
      modelica_string _n = NULL;
      modelica_metatype _subs = NULL;
      modelica_metatype _s = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 4; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_2)) goto tmp2_end;
          
          _cref = tmp3_1;
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 5289 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _cref;
#line 6897 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (listEmpty(tmp3_2)) goto tmp2_end;
          tmpMeta[2] = MMC_CAR(tmp3_2);
          tmpMeta[3] = MMC_CDR(tmp3_2);
          if (!listEmpty(tmpMeta[3])) goto tmp2_end;
          _n = tmpMeta[1];
          _s = tmpMeta[2];
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 5291 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _n, _s);
#line 5291 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 6914 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          if (listEmpty(tmp3_2)) goto tmp2_end;
          tmpMeta[3] = MMC_CAR(tmp3_2);
          tmpMeta[4] = MMC_CDR(tmp3_2);
          _n = tmpMeta[1];
          _cref = tmpMeta[2];
          _s = tmpMeta[3];
          _subs = tmpMeta[4];
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 5294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
#line 6931 OMC_FILE
#line 5295 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _n, _s, _cref2);
#line 5295 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 6936 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _cref = tmpMeta[1];
          _subs = tmp3_2;
          /* Pattern matching succeeded */
#line 5299 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
#line 6948 OMC_FILE
#line 5300 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cref2);
#line 6951 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 4) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

Here is the caller graph for this function:

omc_Absyn_crefIsFullyQualified()

DLLExport modelica_boolean omc_Absyn_crefIsFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 10601 of file Absyn.c.

{
  modelica_boolean _outIsFullyQualified;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10607 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inCref;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4386 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 10623 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 10631 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsFullyQualified = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsFullyQualified;
}

Here is the caller graph for this function:

omc_Absyn_crefIsIdent()

DLLExport modelica_boolean omc_Absyn_crefIsIdent	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11585 of file Absyn.c.

{
  modelica_boolean _outIsIdent;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11591 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inComponentRef;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4147 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 11607 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 11615 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsIdent;
}

Here is the caller graph for this function:

omc_Absyn_crefIsQual()

DLLExport modelica_boolean omc_Absyn_crefIsQual	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11521 of file Absyn.c.

{
  modelica_boolean _outIsQual;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11527 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inComponentRef;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 4158 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 11540 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4159 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 11548 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 4160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 11557 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsQual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsQual;
}

Here is the caller graph for this function:

omc_Absyn_crefLastIdent()

DLLExport modelica_string omc_Absyn_crefLastIdent	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11718 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11725 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inComponentRef;
    {
      modelica_metatype _cref = NULL;
      modelica_string _id = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _id = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _id;
#line 11743 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          _cref = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cref;
#line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11759 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _cref = tmpMeta[0];
          /* Pattern matching succeeded */
#line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cref;
#line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11775 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

omc_Absyn_crefLastSubs()

DLLExport modelica_metatype omc_Absyn_crefLastSubs	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11446 of file Absyn.c.

{
  modelica_metatype _outSubscriptLst = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11452 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_metatype _subs = NULL;
      modelica_metatype _cr = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _subs = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4174 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _subs;
#line 11469 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cr;
#line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11485 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cr;
#line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11501 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outSubscriptLst = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outSubscriptLst;
}

Here is the caller graph for this function:

omc_Absyn_crefMakeFullyQualified()

DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 10549 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10555 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 4397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inComponentRef;
#line 10571 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4398 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _inComponentRef);
#line 4398 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 10581 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

Here is the caller graph for this function:

omc_Absyn_crefPrefixOf()

DLLExport modelica_boolean omc_Absyn_crefPrefixOf	(	threadData_t *	threadData,
		modelica_metatype	_prefixCr,
		modelica_metatype	_cr
	)

Definition at line 14470 of file Absyn.c.

{
  modelica_boolean _out;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14476 OMC_FILE
  { /* matchcontinue expression */
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          /* Pattern matching succeeded */
#line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = omc_Absyn_crefEqualNoSubs(threadData, _prefixCr, _cr);
#line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 14496 OMC_FILE
#line 3299 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 14499 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          /* Pattern matching succeeded */
#line 3301 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefPrefixOf(threadData, _prefixCr, omc_Absyn_crefStripLast(threadData, _cr));
#line 14506 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          /* Pattern matching succeeded */
#line 3302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 14513 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 3) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _out = tmp1;
  _return: OMC_LABEL_UNUSED
  return _out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefRemovePrefix()

DLLExport modelica_metatype omc_Absyn_crefRemovePrefix	(	threadData_t *	threadData,
		modelica_metatype	_prefixCr,
		modelica_metatype	_cr
	)

Definition at line 14139 of file Absyn.c.

{
  modelica_metatype _out = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14145 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _prefixCr;
    tmp3_2 = _cr;
    {
      modelica_string _prefixIdent = NULL;
      modelica_string _ident = NULL;
      modelica_metatype _prefixRestCr = NULL;
      modelica_metatype _restCr = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 4; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,1) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          _prefixRestCr = tmpMeta[1];
          _restCr = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _prefixCr = _prefixRestCr;
#line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = _restCr;
#line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14178 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,3) == 0) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 4));
          _prefixIdent = tmpMeta[1];
          _prefixRestCr = tmpMeta[2];
          _ident = tmpMeta[3];
          _restCr = tmpMeta[4];
          /* Pattern matching succeeded */
#line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (stringEqual(_prefixIdent, _ident));
#line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 14200 OMC_FILE
#line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _prefixCr = _prefixRestCr;
#line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = _restCr;
#line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14211 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,3) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 4));
          _prefixIdent = tmpMeta[1];
          _ident = tmpMeta[2];
          _restCr = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_prefixIdent, _ident));
#line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_1;
#line 14231 OMC_FILE
#line 3396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _restCr;
#line 14234 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,2) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          
          _prefixIdent = tmpMeta[1];
          _ident = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = (stringEqual(_prefixIdent, _ident));
#line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_1;
#line 14253 OMC_FILE
#line 3401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _OMC_LIT56;
#line 14256 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _out = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _out;
}

omc_Absyn_crefReplaceFirstIdent()

DLLExport modelica_metatype omc_Absyn_crefReplaceFirstIdent	(	threadData_t *	threadData,
		modelica_metatype	_icref,
		modelica_metatype	_replPath
	)

Definition at line 14698 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14704 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _icref;
    {
      modelica_metatype _subs = NULL;
      modelica_metatype _cr = NULL;
      modelica_metatype _cref = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3246 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = omc_Absyn_crefReplaceFirstIdent(threadData, _cr, _replPath);
#line 14722 OMC_FILE
#line 3247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr);
#line 14725 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _subs = tmpMeta[1];
          _cr = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = omc_Absyn_pathToCref(threadData, _replPath);
#line 14737 OMC_FILE

#line 3251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = omc_Absyn_addSubscriptsLast(threadData, _cref, _subs);
#line 14741 OMC_FILE
#line 3252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinCrefs(threadData, _cref, _cr);
#line 14744 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _subs = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3255 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = omc_Absyn_pathToCref(threadData, _replPath);
#line 14754 OMC_FILE
#line 3256 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_addSubscriptsLast(threadData, _cref, _subs);
#line 14757 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefSecondIdent()

DLLExport modelica_string omc_Absyn_crefSecondIdent	(	threadData_t *	threadData,
		modelica_metatype	_cref
	)

Definition at line 10783 of file Absyn.c.

{
  modelica_string _ident = NULL;
  modelica_string tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10789 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _cref;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4352 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefFirstIdent(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 4))));
#line 10805 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 2)));
#line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 10820 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _ident = tmp1;
  _return: OMC_LABEL_UNUSED
  return _ident;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefSetLastSubs()

DLLExport modelica_metatype omc_Absyn_crefSetLastSubs	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_metatype	_inSubscripts
	)

Definition at line 11363 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outCref = _inCref;
#line 11370 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outCref;
    {
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          
          /* Pattern matching succeeded */
#line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(4));
#line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 4*sizeof(modelica_metatype));
#line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[3] = _inSubscripts;
#line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outCref = tmpMeta[1];
#line 11389 OMC_FILE
#line 4197 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outCref;
#line 11392 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
#line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 5*sizeof(modelica_metatype));
#line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[4] = omc_Absyn_crefSetLastSubs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outCref), 4))), _inSubscripts);
#line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outCref = tmpMeta[1];
#line 11406 OMC_FILE
#line 4203 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outCref;
#line 11409 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(3));
#line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 3*sizeof(modelica_metatype));
#line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = omc_Absyn_crefSetLastSubs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outCref), 2))), _inSubscripts);
#line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outCref = tmpMeta[1];
#line 11423 OMC_FILE
#line 4209 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outCref;
#line 11426 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

omc_Absyn_crefString()

DLLExport modelica_string omc_Absyn_crefString	(	threadData_t *	threadData,
		modelica_metatype	_inCr
	)

Definition at line 4365 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outStr = omc_Dump_printComponentRefStr(threadData, _inCr);
#line 4372 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefStringIgnoreSubs()

DLLExport modelica_string omc_Absyn_crefStringIgnoreSubs	(	threadData_t *	threadData,
		modelica_metatype	_inCr
	)

Definition at line 4263 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  modelica_metatype _p = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5943 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _inCr);
#line 4271 OMC_FILE

#line 5944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outStr = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _p), _OMC_LIT1, 1, 0);
#line 4275 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_crefStripFirst()

DLLExport modelica_metatype omc_Absyn_crefStripFirst	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 10659 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10665 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_metatype _cr = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4376 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _cr;
#line 10683 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inComponentRef = _cr;
#line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 10699 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

omc_Absyn_crefStripLast()

DLLExport modelica_metatype omc_Absyn_crefStripLast	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 12319 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12325 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      modelica_string _str = NULL;
      modelica_metatype _c_1 = NULL;
      modelica_metatype _c = NULL;
      modelica_metatype _subs = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 4; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3934 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_1;
#line 12345 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],2,2) == 0) goto tmp2_end;
          
          _str = tmpMeta[1];
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3935 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _str, _subs);
#line 3935 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12362 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _str = tmpMeta[1];
          _subs = tmpMeta[2];
          _c = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3938 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c_1 = omc_Absyn_crefStripLast(threadData, _c);
#line 12376 OMC_FILE
#line 3939 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _str, _subs, _c_1);
#line 3939 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12381 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _c = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3943 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c_1 = omc_Absyn_crefStripLast(threadData, _c);
#line 12391 OMC_FILE
#line 3944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c_1);
#line 12394 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

Here is the caller graph for this function:

omc_Absyn_crefStripLastSubs()

DLLExport modelica_metatype omc_Absyn_crefStripLastSubs	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11009 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11015 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_string _id = NULL;
      modelica_metatype _s = NULL;
      modelica_metatype _cr_1 = NULL;
      modelica_metatype _cr = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _id = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, tmpMeta[1]);
#line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 11039 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _id = tmpMeta[1];
          _s = tmpMeta[2];
          _cr = tmpMeta[3];
          /* Pattern matching succeeded */
#line 4297 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr_1 = omc_Absyn_crefStripLastSubs(threadData, _cr);
#line 11053 OMC_FILE
#line 4298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _s, _cr_1);
#line 4298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 11058 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr_1 = omc_Absyn_crefStripLastSubs(threadData, _cr);
#line 11068 OMC_FILE
#line 4303 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr_1);
#line 11071 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

Here is the caller graph for this function:

omc_Absyn_crefToPath()

DLLExport modelica_metatype omc_Absyn_crefToPath	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 12077 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12083 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_string _i = NULL;
      modelica_metatype _p = NULL;
      modelica_metatype _c = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (!listEmpty(tmpMeta[2])) goto tmp2_end;
          _i = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _i);
#line 4004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12105 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (!listEmpty(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _i = tmpMeta[1];
          _c = tmpMeta[3];
          /* Pattern matching succeeded */
#line 4007 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_crefToPath(threadData, _c);
#line 12119 OMC_FILE
#line 4008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _i, _p);
#line 4008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12124 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _c = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_crefToPath(threadData, _c);
#line 12134 OMC_FILE
#line 4013 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
#line 4013 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12139 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_crefToPathIgnoreSubs()

DLLExport modelica_metatype omc_Absyn_crefToPathIgnoreSubs	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef
	)

Definition at line 11953 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11959 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComponentRef;
    {
      modelica_string _i = NULL;
      modelica_metatype _p = NULL;
      modelica_metatype _c = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _i = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _i);
#line 4041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 11980 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _i = tmpMeta[1];
          _c = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4045 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _c);
#line 11992 OMC_FILE
#line 4046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _i, _p);
#line 4046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 11997 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _c = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _c);
#line 12007 OMC_FILE
#line 4052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
#line 4052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12012 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_directionEqual()

DLLExport modelica_boolean omc_Absyn_directionEqual	(	threadData_t *	threadData,
		modelica_metatype	_inDirection1,
		modelica_metatype	_inDirection2
	)

Definition at line 6127 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6133 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inDirection1;
    tmp4_2 = _inDirection2;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 5; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6150 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5452 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6159 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5453 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6168 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,3,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5454 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6177 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 5455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6185 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outEqual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outEqual;
}

Here is the caller graph for this function:

omc_Absyn_dummyTraverseExp()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_dummyTraverseExp	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 3318 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExp = _inExp;
#line 3326 OMC_FILE

#line 6201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outArg = _inArg;
#line 3330 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outExp;
}

omc_Absyn_eachEqual()

DLLExport modelica_boolean omc_Absyn_eachEqual	(	threadData_t *	threadData,
		modelica_metatype	_each1,
		modelica_metatype	_each2
	)

Definition at line 9422 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9428 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _each1;
    tmp4_2 = _each2;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9445 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9454 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 4656 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9462 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _equal = tmp1;
  _return: OMC_LABEL_UNUSED
  return _equal;
}

Here is the caller graph for this function:

omc_Absyn_elementArgEqualName()

DLLExport modelica_boolean omc_Absyn_elementArgEqualName	(	threadData_t *	threadData,
		modelica_metatype	_inArg1,
		modelica_metatype	_inArg2
	)

Definition at line 2135 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype _name1 = NULL;
  modelica_metatype _name2 = NULL;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2144 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inArg1;
    tmp4_2 = _inArg2;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,6) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
          
          _name1 = tmpMeta[0];
          _name2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6551 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathEqual(threadData, _name1, _name2);
#line 2166 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 2174 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outEqual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outEqual;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_elementArgName()

DLLExport modelica_metatype omc_Absyn_elementArgName	(	threadData_t *	threadData,
		modelica_metatype	_inArg
	)

Definition at line 2202 of file Absyn.c.

{
  modelica_metatype _outName = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2208 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inArg;
    {
      modelica_metatype _e = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _outName = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6537 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outName;
#line 2227 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,6) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          
          _e = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6538 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_makeIdentPathFromString(threadData, omc_Absyn_elementSpecName(threadData, _e));
#line 2238 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outName = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_elementSpecName()

DLLExport modelica_string omc_Absyn_elementSpecName	(	threadData_t *	threadData,
		modelica_metatype	_inElementSpec
	)

Definition at line 18064 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 18071 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inElementSpec;
    {
      modelica_string _n = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 18091 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (listEmpty(tmpMeta[0])) goto tmp3_end;
          tmpMeta[1] = MMC_CAR(tmpMeta[0]);
          tmpMeta[2] = MMC_CDR(tmpMeta[0]);
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          if (!listEmpty(tmpMeta[2])) goto tmp3_end;
          _n = tmpMeta[4];
          /* Pattern matching succeeded */
#line 2456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 18107 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

Here is the caller graph for this function:

omc_Absyn_elementSpecToPath()

DLLExport modelica_metatype omc_Absyn_elementSpecToPath	(	threadData_t *	threadData,
		modelica_metatype	_inElementSpec
	)

Definition at line 12032 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12038 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inElementSpec;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 12057 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_expComponentRefStr()

DLLExport modelica_string omc_Absyn_expComponentRefStr	(	threadData_t *	threadData,
		modelica_metatype	_aexp
	)

Definition at line 17865 of file Absyn.c.

{
  modelica_string _outString = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2519 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outString = omc_Absyn_printComponentRefStr(threadData, omc_Absyn_expCref(threadData, _aexp));
#line 17872 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the call graph for this function:

omc_Absyn_expContainsInitial()

DLLExport modelica_boolean omc_Absyn_expContainsInitial	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 5204 of file Absyn.c.

{
  modelica_boolean _hasInitial;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5211 OMC_FILE
  { /* matchcontinue expression */
    {
      modelica_boolean _b;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_integer tmp6;
          /* Pattern matching succeeded */
#line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching tuple assignment, wild first pattern */
#line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_Absyn_traverseExp(threadData, _inExp, boxvar_Absyn_isInitialTraverseHelper, mmc_mk_boolean(0), &tmpMeta[0]);
#line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = mmc_unbox_integer(tmpMeta[0]);
#line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b = tmp6  /* pattern as ty=Boolean */;
#line 5234 OMC_FILE
#line 5675 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _b;
#line 5237 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          /* Pattern matching succeeded */
#line 5677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 5244 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 2) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _hasInitial = tmp1;
  _return: OMC_LABEL_UNUSED
  return _hasInitial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_expCref()

DLLExport modelica_metatype omc_Absyn_expCref	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 17894 of file Absyn.c.

{
  modelica_metatype _cr = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _exp;
#line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,1) == 0) MMC_THROW_INTERNAL();
#line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _cr = tmpMeta[1];
#line 17910 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _cr;
}

Here is the caller graph for this function:

omc_Absyn_expEqual()

DLLExport modelica_boolean omc_Absyn_expEqual	(	threadData_t *	threadData,
		modelica_metatype	_exp1,
		modelica_metatype	_exp2
	)

Definition at line 9490 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9497 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _exp1;
    tmp4_2 = _exp2;
    {
      modelica_metatype _x = NULL;
      modelica_metatype _y = NULL;
      modelica_integer _i;
      modelica_string _r = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_integer tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmp6 = mmc_unbox_integer(tmpMeta[0]);
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _i = tmp6  /* pattern as ty=Integer */;
          _r = tmpMeta[1];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (((modelica_real)((modelica_integer)_i)) == stringReal(_r));
#line 9527 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_integer tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmp7 = mmc_unbox_integer(tmpMeta[1]);
          _r = tmpMeta[0];
          _i = tmp7  /* pattern as ty=Integer */;
          /* Pattern matching succeeded */
#line 4640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (((modelica_real)((modelica_integer)_i)) == stringReal(_r));
#line 9542 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          _x = tmp4_1;
          _y = tmp4_2;
          /* Pattern matching succeeded */
#line 4644 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = valueEq(_x, _y);
#line 9552 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 3) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _equal = tmp1;
  _return: OMC_LABEL_UNUSED
  return _equal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_expString()

DLLExport modelica_string omc_Absyn_expString	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 17916 of file Absyn.c.

{
  modelica_string _str = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _exp;
#line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],3,1) == 0) MMC_THROW_INTERNAL();
#line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _str = tmpMeta[1];
#line 17932 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _str;
}

omc_Absyn_filterAnnotationItem()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_filterAnnotationItem	(	threadData_t *	threadData,
		modelica_metatype	_elt
	)

Definition at line 5557 of file Absyn.c.

{
  modelica_boolean _outB;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5563 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _elt;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 5579 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 5587 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outB = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outB;
}

Here is the caller graph for this function:

omc_Absyn_findIteratorIndexedCrefs()

DLLExport modelica_metatype omc_Absyn_findIteratorIndexedCrefs	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_string	_inIterator,
		modelica_metatype	_inCrefs
	)

Definition at line 9312 of file Absyn.c.

{
  modelica_metatype _outCrefs = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box1(0, _inIterator);
#line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  omc_Absyn_traverseExp(threadData, _inExp, (modelica_fnptr) mmc_mk_box2(0,closure6_Absyn_findIteratorIndexedCrefs__traverser,tmpMeta[0]), tmpMeta[1] ,&_outCrefs);
#line 9324 OMC_FILE

#line 4697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box1(0, boxvar_Absyn_iteratorIndexedCrefsEqual);
#line 4697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outCrefs = omc_List_fold(threadData, _outCrefs, (modelica_fnptr) mmc_mk_box2(0,closure7_List_unionEltOnTrue,tmpMeta[0]), _inCrefs);
#line 9330 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outCrefs;
}

Here is the caller graph for this function:

omc_Absyn_findIteratorIndexedCrefs__traverser()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_findIteratorIndexedCrefs__traverser	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inCrefs,
		modelica_string	_inIterator,
		modelica_metatype *	out_outCrefs
	)

Definition at line 9248 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outCrefs = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outExp = _inExp;
#line 9256 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inExp;
    {
      modelica_metatype _cref = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4715 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, _inCrefs);
#line 9274 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4717 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inCrefs;
#line 9282 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCrefs = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  if (out_outCrefs) { *out_outCrefs = _outCrefs; }
  return _outExp;
}

Here is the call graph for this function:

omc_Absyn_functionArgsEqual()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_functionArgsEqual	(	threadData_t *	threadData,
		modelica_metatype	_args1,
		modelica_metatype	_args2
	)

Definition at line 9355 of file Absyn.c.

{
  modelica_boolean _equal;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9362 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _args1;
    tmp4_2 = _args2;
    {
      modelica_metatype _expl1 = NULL;
      modelica_metatype _expl2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _expl1 = tmpMeta[0];
          _expl2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_List_isEqualOnTrue(threadData, _expl1, _expl2, boxvar_Absyn_expEqual);
#line 9386 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9394 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _equal = tmp1;
  _return: OMC_LABEL_UNUSED
  return _equal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getArrayDimOptAsList()

DLLExport modelica_metatype omc_Absyn_getArrayDimOptAsList	(	threadData_t *	threadData,
		modelica_metatype	_inArrayDim
	)

Definition at line 4066 of file Absyn.c.

{
  modelica_metatype _outArrayDim = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4072 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inArrayDim;
    {
      modelica_metatype _ad = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          _ad = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5990 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _ad;
#line 4090 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5991 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5991 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 4100 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outArrayDim = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outArrayDim;
}

omc_Absyn_getClassName()

DLLExport modelica_string omc_Absyn_getClassName	(	threadData_t *	threadData,
		modelica_metatype	_inClass
	)

Definition at line 9336 of file Absyn.c.

{
  modelica_string _outName = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inClass;
#line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outName = tmpMeta[1];
#line 9350 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outName;
}

omc_Absyn_getCrefFromExp()

DLLExport modelica_metatype omc_Absyn_getCrefFromExp	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_boolean	_includeSubs,
		modelica_boolean	_includeFunctions
	)

Definition at line 13198 of file Absyn.c.

{
  modelica_metatype _outComponentRefLst = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 13204 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_boolean tmp3_2;
    tmp3_1 = _inExp;
    tmp3_2 = _includeSubs;
    {
      modelica_metatype _cr = NULL;
      modelica_metatype _l1 = NULL;
      modelica_metatype _l2 = NULL;
      modelica_metatype _res = NULL;
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      modelica_metatype _e3 = NULL;
      modelica_metatype _farg = NULL;
      modelica_metatype _expl = NULL;
      modelica_metatype _expll = NULL;
      modelica_metatype _subs = NULL;
      modelica_metatype _lstres1 = NULL;
      modelica_metatype _crefll = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 29; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13236 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13247 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13258 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13269 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,0) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13282 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],3,0) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13295 OMC_FILE
          goto tmp2_done;
        }
        case 6: {
          if (0 != tmp3_2) goto tmp2_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_cr, MMC_REFSTRUCTLIT(mmc_nil));
#line 3559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13308 OMC_FILE
          goto tmp2_done;
        }
        case 7: {
          if (1 != tmp3_2) goto tmp2_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cr = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _subs = omc_Absyn_getSubsFromCref(threadData, _cr, _includeSubs, _includeFunctions);
#line 13319 OMC_FILE

#line 3564 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefsFromSubs(threadData, _subs, _includeSubs, _includeFunctions);
#line 13323 OMC_FILE
#line 3565 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_cr, _l1);
#line 3565 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13328 OMC_FILE
          goto tmp2_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13341 OMC_FILE

#line 3570 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13345 OMC_FILE
#line 3571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13348 OMC_FILE
          goto tmp2_done;
        }
        case 9: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,6,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _e1 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inExp = _e1;
#line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 13365 OMC_FILE
          goto tmp2_done;
        }
        case 10: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,7,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13378 OMC_FILE

#line 3584 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13382 OMC_FILE
#line 3585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13385 OMC_FILE
          goto tmp2_done;
        }
        case 11: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,8,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _e1 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inExp = _e1;
#line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 13402 OMC_FILE
          goto tmp2_done;
        }
        case 12: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,9,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13415 OMC_FILE

#line 3598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13419 OMC_FILE
#line 3599 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13422 OMC_FILE
          goto tmp2_done;
        }
        case 13: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[2];
          _e3 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions), mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions), mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e3, _includeSubs, _includeFunctions), MMC_REFSTRUCTLIT(mmc_nil))));
#line 3605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_flatten(threadData, tmpMeta[1]);
#line 13439 OMC_FILE
          goto tmp2_done;
        }
        case 14: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,11,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _cr = tmpMeta[1];
          _farg = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3612 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = omc_Absyn_getCrefFromFarg(threadData, _farg, _includeSubs, _includeFunctions);
#line 13453 OMC_FILE
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (modelica_boolean)_includeFunctions;
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp5)
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = mmc_mk_cons(_cr, _res);
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = tmpMeta[1];
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = _res;
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 13476 OMC_FILE
          goto tmp2_done;
        }
        case 15: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,12,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _cr = tmpMeta[1];
          _farg = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3618 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = omc_Absyn_getCrefFromFarg(threadData, _farg, _includeSubs, _includeFunctions);
#line 13490 OMC_FILE
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)_includeFunctions;
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = mmc_mk_cons(_cr, _res);
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = tmpMeta[1];
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = _res;
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 13513 OMC_FILE
          goto tmp2_done;
        }
        case 16: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,13,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _expl = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _lstres1 = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13524 OMC_FILE
#line 3625 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_flatten(threadData, _lstres1);
#line 13527 OMC_FILE
          goto tmp2_done;
        }
        case 17: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,14,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _expll = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3630 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_flatten(threadData, omc_List_flatten(threadData, omc_List_map2List(threadData, _expll, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions))));
#line 13538 OMC_FILE
          goto tmp2_done;
        }
        case 18: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,15,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e3 = tmpMeta[3];
          _e2 = tmpMeta[4];
          /* Pattern matching succeeded */
#line 3635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13555 OMC_FILE

#line 3636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13559 OMC_FILE

#line 3637 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = listAppend(_l1, _l2);
#line 13563 OMC_FILE

#line 3638 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e3, _includeSubs, _includeFunctions);
#line 13567 OMC_FILE
#line 3639 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13570 OMC_FILE
          goto tmp2_done;
        }
        case 19: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,15,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (!optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3644 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13585 OMC_FILE

#line 3645 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13589 OMC_FILE
#line 3646 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13592 OMC_FILE
          goto tmp2_done;
        }
        case 20: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,17,0) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13603 OMC_FILE
          goto tmp2_done;
        }
        case 21: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,16,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _expl = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefll = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13614 OMC_FILE
#line 3655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_flatten(threadData, _crefll);
#line 13617 OMC_FILE
          goto tmp2_done;
        }
        case 22: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,18,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3659 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3659 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13628 OMC_FILE
          goto tmp2_done;
        }
        case 23: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,19,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _e1 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inExp = _e1;
#line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 13645 OMC_FILE
          goto tmp2_done;
        }
        case 24: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,20,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _e1 = tmpMeta[1];
          _e2 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3665 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
#line 13658 OMC_FILE

#line 3666 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
#line 13662 OMC_FILE
#line 3667 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_l1, _l2);
#line 13665 OMC_FILE
          goto tmp2_done;
        }
        case 25: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,22,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _expl = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3673 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefll = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13676 OMC_FILE
#line 3674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_flatten(threadData, _crefll);
#line 13679 OMC_FILE
          goto tmp2_done;
        }
        case 26: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,21,5) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_1;
#line 13688 OMC_FILE
          goto tmp2_done;
        }
        case 27: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,23,2) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inExp = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2)));
#line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 13703 OMC_FILE
          goto tmp2_done;
        }
        case 28: {
          
          /* Pattern matching succeeded */
#line 3686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = stringAppend(_OMC_LIT53,omc_Dump_printExpStr(threadData, _inExp));
#line 3686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_Error_addInternalError(threadData, tmpMeta[1], _OMC_LIT55);
#line 13713 OMC_FILE
#line 3687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_1;
#line 13716 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRefLst = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRefLst;
}

Here is the caller graph for this function:

omc_Absyn_getCrefFromFarg()

DLLExport modelica_metatype omc_Absyn_getCrefFromFarg	(	threadData_t *	threadData,
		modelica_metatype	_inFunctionArgs,
		modelica_boolean	_includeSubs,
		modelica_boolean	_includeFunctions
	)

Definition at line 13087 of file Absyn.c.

{
  modelica_metatype _outComponentRefLst = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 13093 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inFunctionArgs;
    {
      modelica_metatype _l1 = NULL;
      modelica_metatype _l2 = NULL;
      modelica_metatype _fl1 = NULL;
      modelica_metatype _fl2 = NULL;
      modelica_metatype _fl3 = NULL;
      modelica_metatype _expl = NULL;
      modelica_metatype _nargl = NULL;
      modelica_metatype _iterators = NULL;
      modelica_metatype _exp = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _expl = tmpMeta[1];
          _nargl = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3709 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13121 OMC_FILE

#line 3710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fl1 = omc_List_flatten(threadData, _l1);
#line 13125 OMC_FILE

#line 3711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_List_map2(threadData, _nargl, boxvar_Absyn_getCrefFromNarg, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13129 OMC_FILE

#line 3712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fl2 = omc_List_flatten(threadData, _l2);
#line 13133 OMC_FILE
#line 3713 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_fl1, _fl2);
#line 13136 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _exp = tmpMeta[1];
          _iterators = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3719 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l1 = omc_List_map2Option(threadData, omc_List_map(threadData, _iterators, boxvar_Absyn_iteratorRange), boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13148 OMC_FILE

#line 3720 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _l2 = omc_List_map2Option(threadData, omc_List_map(threadData, _iterators, boxvar_Absyn_iteratorGuard), boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
#line 13152 OMC_FILE

#line 3721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fl1 = omc_List_flatten(threadData, _l1);
#line 13156 OMC_FILE

#line 3722 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fl2 = omc_List_flatten(threadData, _l2);
#line 13160 OMC_FILE

#line 3723 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fl3 = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
#line 13164 OMC_FILE
#line 3724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_fl1, listAppend(_fl2, _fl3));
#line 13167 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRefLst = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRefLst;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getCrefFromNarg()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getCrefFromNarg	(	threadData_t *	threadData,
		modelica_metatype	_inNamedArg,
		modelica_boolean	_includeSubs,
		modelica_boolean	_includeFunctions
	)

Definition at line 12890 of file Absyn.c.

{
  modelica_metatype _outComponentRefLst = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12896 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inNamedArg;
    {
      modelica_metatype _exp = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _exp = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
#line 12913 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRefLst = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRefLst;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getCrefsFromSubs()

DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs	(	threadData_t *	threadData,
		modelica_metatype	_isubs,
		modelica_boolean	_includeSubs,
		modelica_boolean	_includeFunctions
	)

Definition at line 13747 of file Absyn.c.

{
  modelica_metatype _crefs = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 13753 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _isubs;
    {
      modelica_metatype _crefs1 = NULL;
      modelica_metatype _exp = NULL;
      modelica_metatype _subs = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 3518 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3518 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 13773 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp2_end;
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _isubs = _subs;
#line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 13791 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          _exp = tmpMeta[3];
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefs1 = omc_Absyn_getCrefsFromSubs(threadData, _subs, _includeSubs, _includeFunctions);
#line 13805 OMC_FILE

#line 3525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefs = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
#line 13809 OMC_FILE
#line 3526 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_crefs, _crefs1);
#line 13812 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _crefs = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _crefs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getDefineUnitsInElements()

DLLExport modelica_metatype omc_Absyn_getDefineUnitsInElements	(	threadData_t *	threadData,
		modelica_metatype	_elts
	)

Definition at line 3232 of file Absyn.c.

{
  modelica_metatype _outElts = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3238 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;
    tmp3_1 = _elts;
    {
      modelica_metatype _e = NULL;
      modelica_metatype _rest = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3260 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,1) == 0) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],1,2) == 0) goto tmp2_end;
          
          _e = tmpMeta[3];
          _rest = tmpMeta[2];
          /* Pattern matching succeeded */
#line 6215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outElts = omc_Absyn_getDefineUnitsInElements(threadData, _rest);
#line 3276 OMC_FILE
#line 6216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_e, _outElts);
#line 6216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3281 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          _rest = tmpMeta[2];
          /* Pattern matching succeeded */
#line 6218 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_getDefineUnitsInElements(threadData, _rest);
#line 3292 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 3) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outElts = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outElts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getElementItemsInClass()

DLLExport modelica_metatype omc_Absyn_getElementItemsInClass	(	threadData_t *	threadData,
		modelica_metatype	_inClass
	)

Definition at line 3164 of file Absyn.c.

{
  modelica_metatype _outElements = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3170 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inClass;
    {
      modelica_metatype _parts = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
          
          _parts = tmpMeta[2];
          /* Pattern matching succeeded */
#line 6232 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_mapFlat(threadData, _parts, boxvar_Absyn_getElementItemsInClassPart);
#line 3190 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
          
          _parts = tmpMeta[2];
          /* Pattern matching succeeded */
#line 6235 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_mapFlat(threadData, _parts, boxvar_Absyn_getElementItemsInClassPart);
#line 3202 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 6237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3212 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outElements = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outElements;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getElementItemsInClassPart()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getElementItemsInClassPart	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart
	)

Definition at line 3101 of file Absyn.c.

{
  modelica_metatype _outElements = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3107 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inClassPart;
    {
      modelica_metatype _elts = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _elts = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _elts;
#line 3123 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _elts = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _elts;
#line 3133 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 6253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3144 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outElements = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outElements;
}

omc_Absyn_getExpsFromArrayDim()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim	(	threadData_t *	threadData,
		modelica_metatype	_inAd,
		modelica_metatype *	out_outExps
	)

Definition at line 6599 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype _outExps = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim__tail(threadData, _inAd, tmpMeta[0] ,&_outExps);
#line 6610 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outExps) { *out_outExps = _outExps; }
  return _hasUnknownDimensions;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getExpsFromArrayDim__tail()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail	(	threadData_t *	threadData,
		modelica_metatype	_inAd,
		modelica_metatype	_inAccumulator,
		modelica_metatype *	out_outExps
	)

Definition at line 6412 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype _outExps = NULL;
  modelica_boolean tmp1_c0 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5383 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5383 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6424 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inAd;
    tmp4_2 = _inAccumulator;
    {
      modelica_metatype _rest = NULL;
      modelica_metatype _e = NULL;
      modelica_metatype _exps = NULL;
      modelica_metatype _acc = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (!listEmpty(tmp4_1)) goto tmp3_end;
          
          _acc = tmp4_2;
          /* Pattern matching succeeded */
#line 5391 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c0 = 0;
#line 5391 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = listReverse(_acc);
#line 6448 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_1);
          tmpMeta[3] = MMC_CDR(tmp4_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp3_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          
          _e = tmpMeta[4];
          _rest = tmpMeta[3];
          _acc = tmp4_2;
          /* Pattern matching succeeded */
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(_e, _acc);
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inAd = _rest;
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inAccumulator = tmpMeta[2];
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 6474 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_1);
          tmpMeta[3] = MMC_CDR(tmp4_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,0) == 0) goto tmp3_end;
          
          _rest = tmpMeta[3];
          _acc = tmp4_2;
          /* Pattern matching succeeded */
#line 5403 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_Absyn_getExpsFromArrayDim__tail(threadData, _rest, _acc ,&_exps);
#line 6488 OMC_FILE
#line 5404 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c0 = 1;
#line 5404 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _exps;
#line 6493 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _hasUnknownDimensions = tmp1_c0;
  _outExps = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outExps) { *out_outExps = _outExps; }
  return _hasUnknownDimensions;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getExpsFromArrayDimOpt()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDimOpt	(	threadData_t *	threadData,
		modelica_metatype	_inAdO,
		modelica_metatype *	out_outExps
	)

Definition at line 6524 of file Absyn.c.

{
  modelica_boolean _hasUnknownDimensions;
  modelica_metatype _outExps = NULL;
  modelica_boolean tmp1_c0 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6536 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inAdO;
    {
      modelica_metatype _ad = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (!optionNone(tmp4_1)) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c0 = 0;
#line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[2];
#line 6556 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (optionNone(tmp4_1)) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
          _ad = tmpMeta[2];
          /* Pattern matching succeeded */
#line 5367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c0 = omc_Absyn_getExpsFromArrayDim__tail(threadData, _ad, tmpMeta[2], &tmpMeta[0+1]);
#line 6568 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _hasUnknownDimensions = tmp1_c0;
  _outExps = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outExps) { *out_outExps = _outExps; }
  return _hasUnknownDimensions;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getExternalDecl()

DLLExport modelica_metatype omc_Absyn_getExternalDecl	(	threadData_t *	threadData,
		modelica_metatype	_inCls
	)

Definition at line 5528 of file Absyn.c.

{
  modelica_metatype _outExternal = NULL;
  modelica_metatype _cp = NULL;
  modelica_metatype _class_parts = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inCls;
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 7));
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) MMC_THROW_INTERNAL();
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
#line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _class_parts = tmpMeta[2];
#line 5548 OMC_FILE

#line 5596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExternal = omc_List_find(threadData, _class_parts, boxvar_Absyn_isExternalPart);
#line 5552 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outExternal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getFileNameFromInfo()

DLLExport modelica_string omc_Absyn_getFileNameFromInfo	(	threadData_t *	threadData,
		modelica_metatype	_inInfo
	)

Definition at line 8829 of file Absyn.c.

{
  modelica_string _inFileName = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inInfo;
#line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _inFileName = tmpMeta[1];
#line 8843 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _inFileName;
}

Here is the caller graph for this function:

omc_Absyn_getFunctionInterface()

DLLExport modelica_metatype omc_Absyn_getFunctionInterface	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5673 of file Absyn.c.

{
  modelica_metatype _o = NULL;
  modelica_metatype tmpMeta[12] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5679 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _cl;
    {
      modelica_string _name = NULL;
      modelica_boolean _partialPrefix;
      modelica_boolean _finalPrefix;
      modelica_boolean _encapsulatedPrefix;
      modelica_metatype _info = NULL;
      modelica_metatype _typeVars = NULL;
      modelica_metatype _classParts = NULL;
      modelica_metatype _elts = NULL;
      modelica_metatype _funcRest = NULL;
      modelica_metatype _classAttr = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          modelica_integer tmp5;
          modelica_integer tmp6;
          modelica_integer tmp7;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmp5 = mmc_unbox_integer(tmpMeta[2]);
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmp6 = mmc_unbox_integer(tmpMeta[3]);
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          tmp7 = mmc_unbox_integer(tmpMeta[4]);
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],9,1) == 0) goto tmp2_end;
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[7],0,5) == 0) goto tmp2_end;
          tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 2));
          tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 3));
          tmpMeta[10] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 4));
          tmpMeta[11] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
          _name = tmpMeta[1];
          _partialPrefix = tmp5  /* pattern as ty=Boolean */;
          _finalPrefix = tmp6  /* pattern as ty=Boolean */;
          _encapsulatedPrefix = tmp7  /* pattern as ty=Boolean */;
          _funcRest = tmpMeta[6];
          _typeVars = tmpMeta[8];
          _classAttr = tmpMeta[9];
          _classParts = tmpMeta[10];
          _info = tmpMeta[11];
          /* Pattern matching succeeded */
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = omc_List_fold(threadData, listReverse(_classParts), boxvar_Absyn_getFunctionInterfaceParts, tmpMeta[1]);
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (listEmpty(tmpMeta[2])) goto goto_1;
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_CAR(tmpMeta[2]);
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_CDR(tmpMeta[2]);
#line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _elts = tmpMeta[2];
#line 5743 OMC_FILE
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(12, &Absyn_Restriction_R__FUNCTION__desc, _funcRest);
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = mmc_mk_box2(3, &Absyn_ClassPart_PUBLIC__desc, _elts);
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(tmpMeta[3], MMC_REFSTRUCTLIT(mmc_nil));
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = mmc_mk_box6(3, &Absyn_ClassDef_PARTS__desc, _typeVars, _classAttr, tmpMeta[2], tmpMeta[4], mmc_mk_none());
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = mmc_mk_box8(3, &Absyn_Class_CLASS__desc, _name, mmc_mk_boolean(_partialPrefix), mmc_mk_boolean(_finalPrefix), mmc_mk_boolean(_encapsulatedPrefix), tmpMeta[1], tmpMeta[5], _info);
#line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[6];
#line 5758 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _o = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the call graph for this function:

omc_Absyn_getFunctionInterfaceParts()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getFunctionInterfaceParts	(	threadData_t *	threadData,
		modelica_metatype	_part,
		modelica_metatype	_elts
	)

Definition at line 5614 of file Absyn.c.

{
  modelica_metatype _oelts = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5620 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _part;
    tmp3_2 = _elts;
    {
      modelica_metatype _elts1 = NULL;
      modelica_metatype _elts2 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _elts1 = tmpMeta[1];
          _elts2 = tmp3_2;
          /* Pattern matching succeeded */
#line 5569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _elts1 = omc_List_filterOnTrue(threadData, _elts1, boxvar_Absyn_filterAnnotationItem);
#line 5642 OMC_FILE
#line 5570 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = listAppend(_elts1, _elts2);
#line 5645 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _elts;
#line 5653 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _oelts = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _oelts;
}

Here is the call graph for this function:

omc_Absyn_getIteratorIndexedCrefs()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getIteratorIndexedCrefs	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_string	_inIterator,
		modelica_metatype	_inCrefs
	)

Definition at line 8931 of file Absyn.c.

{
  modelica_metatype _outCrefs = NULL;
  modelica_metatype _crefs = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outCrefs = _inCrefs;
#line 8939 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      modelica_metatype _subs = NULL;
      modelica_integer _idx;
      modelica_string _name = NULL;
      modelica_string _id = NULL;
      modelica_metatype _cref = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _id = tmpMeta[1];
          _subs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4760 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _idx = ((modelica_integer) 1);
#line 8961 OMC_FILE

#line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _sub;
#line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            for (tmpMeta[1] = _subs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
#line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            {
#line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _sub = MMC_CAR(tmpMeta[1]);
#line 8973 OMC_FILE
              { /* match expression */
                modelica_metatype tmp6_1;
                tmp6_1 = _sub;
                {
                  volatile mmc_switch_type tmp6;
                  int tmp7;
                  tmp6 = 0;
                  for (; tmp6 < 2; tmp6++) {
                    switch (MMC_SWITCH_CAST(tmp6)) {
                    case 0: {
                      if (mmc__uniontype__metarecord__typedef__equal(tmp6_1,1,1) == 0) goto tmp5_end;
                      tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp6_1), 2));
                      if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],2,1) == 0) goto tmp5_end;
                      tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
                      if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],2,2) == 0) goto tmp5_end;
                      tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
                      tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
                      if (!listEmpty(tmpMeta[5])) goto tmp5_end;
                      _name = tmpMeta[4];
                      /* Pattern matching succeeded */
#line 4766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      if((stringEqual(_name, _inIterator)))
#line 4766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      {
#line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                        tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                        tmpMeta[4] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, tmpMeta[3]);
#line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                        tmpMeta[5] = mmc_mk_box2(0, tmpMeta[4], mmc_mk_integer((modelica_integer)_idx));
#line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                        tmpMeta[2] = mmc_mk_cons(tmpMeta[5], _outCrefs);
#line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                        _outCrefs = tmpMeta[2];
#line 9008 OMC_FILE
                      }
#line 9010 OMC_FILE
                      goto tmp5_done;
                    }
                    case 1: {
                      
                      /* Pattern matching succeeded */
#line 9016 OMC_FILE
                      goto tmp5_done;
                    }
                    }
                    goto tmp5_end;
                    tmp5_end: ;
                  }
                  goto goto_4;
                  goto_4:;
                  goto goto_1;
                  goto tmp5_done;
                  tmp5_done:;
                }
              }
              ;

#line 4775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _idx = ((modelica_integer) 1) + (modelica_integer)_idx;
#line 9034 OMC_FILE
            }
          }
#line 4777 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outCrefs;
#line 9039 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          modelica_integer tmp8;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _id = tmpMeta[1];
          _subs = tmpMeta[2];
          _cref = tmpMeta[3];
          /* Pattern matching succeeded */
#line 4782 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4782 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefs = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, tmpMeta[1]);
#line 9056 OMC_FILE

#line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _cr;
#line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            for (tmpMeta[1] = _crefs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
#line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            {
#line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _cr = MMC_CAR(tmpMeta[1]);
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              /* Pattern-matching assignment */
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = _cr;
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp8 = mmc_unbox_integer(tmpMeta[4]);
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _cref = tmpMeta[3];
#line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _idx = tmp8  /* pattern as ty=Integer */;
#line 9082 OMC_FILE

#line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[3] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _subs, _cref);
#line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[4] = mmc_mk_box2(0, tmpMeta[3], mmc_mk_integer((modelica_integer)_idx));
#line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = mmc_mk_cons(tmpMeta[4], _outCrefs);
#line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _outCrefs = tmpMeta[2];
#line 9092 OMC_FILE
            }
          }
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, _subs);
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCref = tmpMeta[1];
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inCrefs = _outCrefs;
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 9107 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          modelica_integer tmp9;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefs = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, tmpMeta[1]);
#line 9120 OMC_FILE

#line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _cr;
#line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            for (tmpMeta[1] = _crefs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
#line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            {
#line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _cr = MMC_CAR(tmpMeta[1]);
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              /* Pattern-matching assignment */
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = _cr;
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp9 = mmc_unbox_integer(tmpMeta[4]);
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _cref = tmpMeta[3];
#line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _idx = tmp9  /* pattern as ty=Integer */;
#line 9146 OMC_FILE

#line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[3] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _cref);
#line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[4] = mmc_mk_box2(0, tmpMeta[3], mmc_mk_integer((modelica_integer)_idx));
#line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = mmc_mk_cons(tmpMeta[4], _outCrefs);
#line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _outCrefs = tmpMeta[2];
#line 9156 OMC_FILE
            }
          }
#line 4802 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outCrefs;
#line 9161 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 4805 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inCrefs;
#line 9170 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCrefs = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCrefs;
}

Here is the caller graph for this function:

omc_Absyn_getNamedAnnotationInClass()

DLLExport modelica_metatype omc_Absyn_getNamedAnnotationInClass	(	threadData_t *	threadData,
		modelica_metatype	_inClass,
		modelica_metatype	_id,
		modelica_fnptr	_f
	)

Definition at line 3690 of file Absyn.c.

{
  modelica_metatype _outString = NULL;
  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3696 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;
    tmp3_1 = _inClass;
    {
      modelica_metatype _str = NULL;
      modelica_metatype _res = NULL;
      modelica_metatype _annlst = NULL;
      modelica_metatype _ann = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 6; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
          
          _ann = tmpMeta[2];
          tmp3 += 4; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _annlst = omc_List_flatten(threadData, omc_List_map(threadData, _ann, boxvar_Absyn_annotationToElementArgs));
#line 3722 OMC_FILE

#line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
#line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (optionNone(tmpMeta[1])) goto goto_1;
#line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str = tmpMeta[2];
#line 3734 OMC_FILE
#line 6054 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_str);
#line 3737 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 6));
          
          _ann = tmpMeta[2];
          tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6059 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _annlst = omc_List_flatten(threadData, omc_List_map(threadData, _ann, boxvar_Absyn_annotationToElementArgs));
#line 3749 OMC_FILE

#line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
#line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (optionNone(tmpMeta[1])) goto goto_1;
#line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str = tmpMeta[2];
#line 3761 OMC_FILE
#line 6061 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_str);
#line 3764 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,4) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
          if (optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          if (optionNone(tmpMeta[4])) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          
          _annlst = tmpMeta[6];
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
#line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (optionNone(tmpMeta[1])) goto goto_1;
#line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = tmpMeta[2];
#line 3790 OMC_FILE
#line 6067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_res);
#line 3793 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
          if (optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          if (optionNone(tmpMeta[4])) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          
          _annlst = tmpMeta[6];
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
#line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (optionNone(tmpMeta[1])) goto goto_1;
#line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = tmpMeta[2];
#line 3819 OMC_FILE
#line 6073 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_res);
#line 3822 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],3,2) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
          if (optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          if (optionNone(tmpMeta[4])) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          
          _annlst = tmpMeta[6];
          /* Pattern matching succeeded */
#line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
#line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (optionNone(tmpMeta[1])) goto goto_1;
#line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = tmpMeta[2];
#line 3848 OMC_FILE
#line 6079 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_res);
#line 3851 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          
          /* Pattern matching succeeded */
#line 6082 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_none();
#line 3859 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 6) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outString = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getNamedAnnotationStr()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getNamedAnnotationStr	(	threadData_t *	threadData,
		modelica_metatype	_inAbsynElementArgLst,
		modelica_metatype	_id,
		modelica_fnptr	_f
	)

Definition at line 3561 of file Absyn.c.

{
  modelica_metatype _outString = NULL;
  modelica_metatype tmpMeta[10] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3567 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
    tmp3_1 = _inAbsynElementArgLst;
    tmp3_2 = _id;
    {
      modelica_metatype _str = NULL;
      modelica_metatype _mod = NULL;
      modelica_metatype _xs = NULL;
      modelica_string _id1 = NULL;
      modelica_string _id2 = NULL;
      modelica_metatype _rest = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[2] = MMC_CAR(tmp3_1);
          tmpMeta[3] = MMC_CDR(tmp3_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,6) == 0) goto tmp2_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,1) == 0) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 5));
          
          _id2 = tmpMeta[1];
          _id1 = tmpMeta[5];
          _mod = tmpMeta[6];
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (stringEqual(_id1, _id2));
#line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 3610 OMC_FILE

#line 6111 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 2))), _mod) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 1)))) (threadData, _mod);
#line 3614 OMC_FILE
#line 6112 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_str);
#line 3617 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[3] = MMC_CAR(tmp3_1);
          tmpMeta[4] = MMC_CDR(tmp3_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],0,6) == 0) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],1,1) == 0) goto tmp2_end;
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 5));
          if (optionNone(tmpMeta[7])) goto tmp2_end;
          tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 1));
          tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[8]), 2));
          
          _id2 = tmpMeta[1];
          _rest = tmpMeta[2];
          _id1 = tmpMeta[6];
          _xs = tmpMeta[9];
          /* Pattern matching succeeded */
#line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id1, _id2));
#line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_1;
#line 3648 OMC_FILE
#line 6118 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_getNamedAnnotationStr(threadData, _xs, _rest, ((modelica_fnptr) _f));
#line 3651 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          
          _xs = tmpMeta[2];
          /* Pattern matching succeeded */
#line 6120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_getNamedAnnotationStr(threadData, _xs, _id, ((modelica_fnptr) _f));
#line 3663 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 3) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outString = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the caller graph for this function:

omc_Absyn_getNamedFuncArgNamesAndValues()

DLLExport modelica_metatype omc_Absyn_getNamedFuncArgNamesAndValues	(	threadData_t *	threadData,
		modelica_metatype	_inNamedArgList,
		modelica_metatype *	out_outExpList
	)

Definition at line 12944 of file Absyn.c.

{
  modelica_metatype _outStringList = NULL;
  modelica_metatype _outExpList = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 3759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 12955 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inNamedArgList;
    {
      modelica_metatype _cdr = NULL;
      modelica_string _s = NULL;
      modelica_metatype _e = NULL;
      modelica_metatype _slst = NULL;
      modelica_metatype _elst = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (!listEmpty(tmp4_1)) goto tmp3_end;
          /* Pattern matching succeeded */
#line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[3];
#line 12981 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_1);
          tmpMeta[3] = MMC_CDR(tmp4_1);
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 3));
          _s = tmpMeta[4];
          _e = tmpMeta[5];
          _cdr = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _slst = omc_Absyn_getNamedFuncArgNamesAndValues(threadData, _cdr ,&_elst);
#line 12996 OMC_FILE
#line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(_s, _slst);
#line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = mmc_mk_cons(_e, _elst);
#line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[3];
#line 13005 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outStringList = tmpMeta[0+0];
  _outExpList = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outExpList) { *out_outExpList = _outExpList; }
  return _outStringList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_getShortClass()

DLLExport modelica_metatype omc_Absyn_getShortClass	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5925 of file Absyn.c.

{
  modelica_metatype _o = NULL;
  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5931 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _cl;
    {
      modelica_string _name = NULL;
      modelica_boolean _pa;
      modelica_boolean _fi;
      modelica_boolean _en;
      modelica_metatype _re = NULL;
      modelica_metatype _body = NULL;
      modelica_metatype _info = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 5499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_1;
#line 5955 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 5500 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_1;
#line 5965 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          modelica_integer tmp5;
          modelica_integer tmp6;
          modelica_integer tmp7;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmp5 = mmc_unbox_integer(tmpMeta[2]);
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmp6 = mmc_unbox_integer(tmpMeta[3]);
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          tmp7 = mmc_unbox_integer(tmpMeta[4]);
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
          _name = tmpMeta[1];
          _pa = tmp5  /* pattern as ty=Boolean */;
          _fi = tmp6  /* pattern as ty=Boolean */;
          _en = tmp7  /* pattern as ty=Boolean */;
          _re = tmpMeta[5];
          _body = tmpMeta[6];
          _info = tmpMeta[7];
          /* Pattern matching succeeded */
#line 5503 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _body = omc_Absyn_stripClassDefComment(threadData, _body);
#line 5992 OMC_FILE
#line 5504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box8(3, &Absyn_Class_CLASS__desc, _name, mmc_mk_boolean(_pa), mmc_mk_boolean(_fi), mmc_mk_boolean(_en), _re, _body, _info);
#line 5504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5997 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _o = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the call graph for this function:

omc_Absyn_getSubsFromCref()

DLLExport modelica_metatype omc_Absyn_getSubsFromCref	(	threadData_t *	threadData,
		modelica_metatype	_cr,
		modelica_boolean	_includeSubs,
		modelica_boolean	_includeFunctions
	)

Definition at line 11171 of file Absyn.c.

{
  modelica_metatype _subscripts = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11177 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _cr;
    {
      modelica_metatype _subs2 = NULL;
      modelica_metatype _child = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _subs2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4242 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _subs2;
#line 11194 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _subs2 = tmpMeta[1];
          _child = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4246 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _subscripts = omc_Absyn_getSubsFromCref(threadData, _child, _includeSubs, _includeFunctions);
#line 11206 OMC_FILE
#line 4247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_List_unionOnTrue(threadData, _subscripts, _subs2, boxvar_Absyn_subscriptEqual);
#line 11209 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _child = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr = _child;
#line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 11225 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _subscripts = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _subscripts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_importEqual()

DLLExport modelica_boolean omc_Absyn_importEqual	(	threadData_t *	threadData,
		modelica_metatype	_im1,
		modelica_metatype	_im2
	)

Definition at line 8142 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8149 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _im1;
    tmp4_2 = _im2;
    {
      modelica_string _id = NULL;
      modelica_string _id2 = NULL;
      modelica_metatype _p1 = NULL;
      modelica_metatype _p2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 4; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _id = tmpMeta[0];
          _p1 = tmpMeta[1];
          _id2 = tmpMeta[2];
          _p2 = tmpMeta[3];
          tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id, _id2));
#line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 8187 OMC_FILE

#line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_2;
#line 8195 OMC_FILE
#line 4949 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8198 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_boolean tmp8;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _p1 = tmpMeta[0];
          _p2 = tmpMeta[1];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp8 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp8) goto goto_2;
#line 8216 OMC_FILE
#line 4954 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8219 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          modelica_boolean tmp9;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _p1 = tmpMeta[0];
          _p2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp9 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp9) goto goto_2;
#line 8237 OMC_FILE
#line 4959 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8240 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4961 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8248 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 4) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _outBoolean = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outBoolean;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_importName()

DLLExport modelica_string omc_Absyn_importName	(	threadData_t *	threadData,
		modelica_metatype	_inImport
	)

Definition at line 4906 of file Absyn.c.

{
  modelica_string _outName = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4913 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inImport;
    {
      modelica_string _name = NULL;
      modelica_metatype _path = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _name = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5744 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _name;
#line 4933 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _path = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5746 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathLastIdent(threadData, _path);
#line 4943 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outName = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_importPath()

DLLExport modelica_metatype omc_Absyn_importPath	(	threadData_t *	threadData,
		modelica_metatype	_inImport
	)

Definition at line 4963 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4969 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inImport;
    {
      modelica_metatype _path = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 4985 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5726 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 4995 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5727 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 5005 OMC_FILE
          goto tmp2_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5728 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 5016 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_importString()

DLLExport modelica_string omc_Absyn_importString	(	threadData_t *	threadData,
		modelica_metatype	_inImp
	)

Definition at line 4250 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5951 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outStr = omc_Dump_unparseImportStr(threadData, _inImp);
#line 4257 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_innerOuterEqual()

DLLExport modelica_boolean omc_Absyn_innerOuterEqual	(	threadData_t *	threadData,
		modelica_metatype	_io1,
		modelica_metatype	_io2
	)

Definition at line 8387 of file Absyn.c.

{
  modelica_boolean _res;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8393 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _io1;
    tmp4_2 = _io2;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 5; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4905 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8410 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4906 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8419 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4907 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8428 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,3,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4908 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8437 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 4909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8445 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _res = tmp1;
  _return: OMC_LABEL_UNUSED
  return _res;
}

Here is the caller graph for this function:

omc_Absyn_innerOuterStr()

DLLExport modelica_string omc_Absyn_innerOuterStr	(	threadData_t *	threadData,
		modelica_metatype	_io
	)

Definition at line 7113 of file Absyn.c.

{
  modelica_string _str = NULL;
  modelica_string tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7119 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _io;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          
          /* Pattern matching succeeded */
#line 5236 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT9;
#line 7132 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 5237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT10;
#line 7140 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 5238 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT11;
#line 7148 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          
          /* Pattern matching succeeded */
#line 5239 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT2;
#line 7156 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _str = tmp1;
  _return: OMC_LABEL_UNUSED
  return _str;
}

Here is the caller graph for this function:

omc_Absyn_isAlgorithmItem()

DLLExport modelica_boolean omc_Absyn_isAlgorithmItem	(	threadData_t *	threadData,
		modelica_metatype	_inAlg
	)

Definition at line 820 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 826 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inAlg;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 842 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 850 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsClass = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsClass;
}

Here is the caller graph for this function:

omc_Absyn_isClassdef()

DLLExport modelica_boolean omc_Absyn_isClassdef	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 18003 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 18010 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inElement;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 18028 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 2466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 18036 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the caller graph for this function:

omc_Absyn_isClassNamed()

DLLExport modelica_boolean omc_Absyn_isClassNamed	(	threadData_t *	threadData,
		modelica_string	_inName,
		modelica_metatype	_inClass
	)

Definition at line 18127 of file Absyn.c.

{
  modelica_boolean _outIsNamed;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 18133 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inClass;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          
          /* Pattern matching succeeded */
#line 2441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_inName, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inClass), 2)))));
#line 18148 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 2442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 18156 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsNamed = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsNamed;
}

Here is the caller graph for this function:

omc_Absyn_isCref()

DLLExport modelica_boolean omc_Absyn_isCref	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 6807 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6813 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _exp;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6829 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6837 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the caller graph for this function:

omc_Absyn_isDerCref()

DLLExport modelica_boolean omc_Absyn_isDerCref	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 6675 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6682 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _exp;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (3 != MMC_STRLEN(tmpMeta[1]) || strcmp(MMC_STRINGDATA(_OMC_LIT8), MMC_STRINGDATA(tmpMeta[1])) != 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
          if (!listEmpty(tmpMeta[2])) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],0,2) == 0) goto tmp3_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          if (listEmpty(tmpMeta[4])) goto tmp3_end;
          tmpMeta[5] = MMC_CAR(tmpMeta[4]);
          tmpMeta[6] = MMC_CDR(tmpMeta[4]);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],2,1) == 0) goto tmp3_end;
          if (!listEmpty(tmpMeta[6])) goto tmp3_end;
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
          if (!listEmpty(tmpMeta[7])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5330 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6713 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5331 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6721 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the caller graph for this function:

omc_Absyn_isDerCrefFail()

DLLExport void omc_Absyn_isDerCrefFail	(	threadData_t *	threadData,
		modelica_metatype	_exp
	)

Definition at line 6626 of file Absyn.c.

{
  modelica_metatype tmpMeta[9] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _exp;
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],11,2) == 0) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (3 != MMC_STRLEN(tmpMeta[2]) || strcmp("der", MMC_STRINGDATA(tmpMeta[2])) != 0) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (!listEmpty(tmpMeta[3])) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],0,2) == 0) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (listEmpty(tmpMeta[5])) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[6] = MMC_CAR(tmpMeta[5]);
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[7] = MMC_CDR(tmpMeta[5]);
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[6],2,1) == 0) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (!listEmpty(tmpMeta[7])) MMC_THROW_INTERNAL();
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 3));
#line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (!listEmpty(tmpMeta[8])) MMC_THROW_INTERNAL();
#line 6669 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return;
}

omc_Absyn_isElementItem()

DLLExport modelica_boolean omc_Absyn_isElementItem	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 878 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 884 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inElement;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6785 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 900 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 908 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsClass = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsClass;
}

Here is the caller graph for this function:

omc_Absyn_isElementItemClass()

DLLExport modelica_boolean omc_Absyn_isElementItemClass	(	threadData_t *	threadData,
		modelica_metatype	_inElement
	)

Definition at line 936 of file Absyn.c.

{
  modelica_boolean _outIsClass;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 943 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inElement;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 963 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6776 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 971 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsClass = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsClass;
}

Here is the caller graph for this function:

omc_Absyn_isElementItemClassNamed()

DLLExport modelica_boolean omc_Absyn_isElementItemClassNamed	(	threadData_t *	threadData,
		modelica_string	_inName,
		modelica_metatype	_inElement
	)

Definition at line 753 of file Absyn.c.

{
  modelica_boolean _outIsNamed;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 760 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inElement;
    {
      modelica_string _name = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          
          _name = tmpMeta[3];
          /* Pattern matching succeeded */
#line 6810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_name, _inName));
#line 784 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 792 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsNamed = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsNamed;
}

Here is the caller graph for this function:

omc_Absyn_isEmptyClassPart()

DLLExport modelica_boolean omc_Absyn_isEmptyClassPart	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart
	)

Definition at line 633 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 640 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inClassPart;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 8; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 657 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6821 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 667 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6822 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 677 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6823 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 687 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 697 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 707 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 717 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          
          /* Pattern matching succeeded */
#line 6827 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 725 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsEmpty = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsEmpty;
}

Here is the caller graph for this function:

omc_Absyn_isEmptyMod()

DLLExport modelica_boolean omc_Absyn_isEmptyMod	(	threadData_t *	threadData,
		modelica_metatype	_inMod
	)

Definition at line 2325 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2332 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inMod;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 6511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 2350 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (!listEmpty(tmpMeta[0])) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],16,1) == 0) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          if (!listEmpty(tmpMeta[3])) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6512 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 2366 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 6513 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 2374 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsEmpty = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsEmpty;
}

Here is the caller graph for this function:

omc_Absyn_isEmptySubMod()

DLLExport modelica_boolean omc_Absyn_isEmptySubMod	(	threadData_t *	threadData,
		modelica_metatype	_inSubMod
	)

Definition at line 2258 of file Absyn.c.

{
  modelica_boolean _outIsEmpty;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2265 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inSubMod;
    {
      modelica_metatype _mod = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          if (!optionNone(tmpMeta[0])) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 2284 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          if (optionNone(tmpMeta[0])) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
          
          _mod = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6526 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_isEmptyMod(threadData, _mod);
#line 2297 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsEmpty = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsEmpty;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_isExternalPart()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_isExternalPart	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart
	)

Definition at line 5470 of file Absyn.c.

{
  modelica_boolean _outFound;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5476 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inClassPart;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5604 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 5492 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 5500 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outFound = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outFound;
}

Here is the caller graph for this function:

omc_Absyn_isFieldEqual()

DLLExport modelica_boolean omc_Absyn_isFieldEqual	(	threadData_t *	threadData,
		modelica_metatype	_isField1,
		modelica_metatype	_isField2
	)

Definition at line 6059 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6065 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _isField1;
    tmp4_2 = _isField2;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6082 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6091 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 5467 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6099 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outEqual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outEqual;
}

Here is the caller graph for this function:

omc_Absyn_isFunctionRestriction()

DLLExport modelica_boolean omc_Absyn_isFunctionRestriction	(	threadData_t *	threadData,
		modelica_metatype	_inRestriction
	)

Definition at line 9587 of file Absyn.c.

{
  modelica_boolean _outIsFunction;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9593 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inRestriction;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 4615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9609 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4616 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9617 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsFunction = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsFunction;
}

Here is the caller graph for this function:

omc_Absyn_isInitial()

DLLExport modelica_boolean omc_Absyn_isInitial	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 5036 of file Absyn.c.

{
  modelica_boolean _hasReinit;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5043 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inExp;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (7 != MMC_STRLEN(tmpMeta[1]) || strcmp(MMC_STRINGDATA(_OMC_LIT6), MMC_STRINGDATA(tmpMeta[1])) != 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 5063 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (7 != MMC_STRLEN(tmpMeta[2]) || strcmp(MMC_STRINGDATA(_OMC_LIT6), MMC_STRINGDATA(tmpMeta[2])) != 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 5078 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 5712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 5086 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _hasReinit = tmp1;
  _return: OMC_LABEL_UNUSED
  return _hasReinit;
}

Here is the caller graph for this function:

omc_Absyn_isInitialTraverseHelper()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_isInitialTraverseHelper	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_boolean	_inBool,
		modelica_boolean *	out_outBool
	)

Definition at line 5113 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_boolean _outBool;
  modelica_boolean tmp1_c1 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5125 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inExp;
    {
      modelica_metatype _e = NULL;
      modelica_boolean _b;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],16,0) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5693 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5693 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c1 = _inBool;
#line 5147 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          _e = tmp4_1;
          /* Pattern matching succeeded */
#line 5697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b = omc_Absyn_isInitial(threadData, _e);
#line 5156 OMC_FILE
#line 5698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _e;
#line 5698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c1 = _b;
#line 5161 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 5699 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5699 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c1 = _inBool;
#line 5171 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outExp = tmpMeta[0+0];
  _outBool = tmp1_c1;
  _return: OMC_LABEL_UNUSED
  if (out_outBool) { *out_outBool = _outBool; }
  return _outExp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_isInner()

DLLExport modelica_boolean omc_Absyn_isInner	(	threadData_t *	threadData,
		modelica_metatype	_io
	)

Definition at line 8701 of file Absyn.c.

{
  modelica_boolean _isItAnInner;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8707 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _io;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          
          /* Pattern matching succeeded */
#line 4851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8720 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 4852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8728 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 4853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8737 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _isItAnInner = tmp1;
  _return: OMC_LABEL_UNUSED
  return _isItAnInner;
}

Here is the caller graph for this function:

omc_Absyn_isInnerOuter()

DLLExport modelica_boolean omc_Absyn_isInnerOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8530 of file Absyn.c.

{
  modelica_boolean _outIsInnerOuter;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8536 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inIO;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8551 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4885 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8559 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsInnerOuter = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsInnerOuter;
}

Here is the caller graph for this function:

omc_Absyn_isInput()

DLLExport modelica_boolean omc_Absyn_isInput	(	threadData_t *	threadData,
		modelica_metatype	_inDirection
	)

Definition at line 6277 of file Absyn.c.

{
  modelica_boolean _outIsInput;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6283 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inDirection;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          
          /* Pattern matching succeeded */
#line 5428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6296 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          
          /* Pattern matching succeeded */
#line 5429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6304 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 5430 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6313 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsInput = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsInput;
}

Here is the caller graph for this function:

omc_Absyn_isInputOrOutput()

DLLExport modelica_boolean omc_Absyn_isInputOrOutput	(	threadData_t *	threadData,
		modelica_metatype	_direction
	)

Definition at line 6341 of file Absyn.c.

{
  modelica_boolean _isIorO;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6347 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _direction;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          
          /* Pattern matching succeeded */
#line 5416 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6360 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 5417 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6368 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          
          /* Pattern matching succeeded */
#line 5418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6376 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          
          /* Pattern matching succeeded */
#line 5419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6384 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _isIorO = tmp1;
  _return: OMC_LABEL_UNUSED
  return _isIorO;
}

Here is the caller graph for this function:

omc_Absyn_isInvariantExpNoTraverse()

DLLExport modelica_metatype omc_Absyn_isInvariantExpNoTraverse	(	threadData_t *	threadData,
		modelica_metatype _	$in_e,
		modelica_boolean _	$in_b,
		modelica_boolean *	out_b
	)

Definition at line 410 of file Absyn.c.

{
  modelica_metatype _e = NULL;
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _e = _$in_e;
  _b = _$in_b;
#line 6835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if((!_b))
#line 6835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 6836 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    goto _return;
#line 426 OMC_FILE
  }

#line 429 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _e;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 18; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6839 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 445 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6840 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 454 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 463 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 472 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6843 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 481 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6844 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 490 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 499 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6846 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 508 OMC_FILE
          goto tmp3_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6847 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 517 OMC_FILE
          goto tmp3_done;
        }
        case 9: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,4) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6848 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 526 OMC_FILE
          goto tmp3_done;
        }
        case 10: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6850 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 537 OMC_FILE
          goto tmp3_done;
        }
        case 11: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,12,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 548 OMC_FILE
          goto tmp3_done;
        }
        case 12: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 557 OMC_FILE
          goto tmp3_done;
        }
        case 13: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 566 OMC_FILE
          goto tmp3_done;
        }
        case 14: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6854 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 575 OMC_FILE
          goto tmp3_done;
        }
        case 15: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,20,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6855 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 584 OMC_FILE
          goto tmp3_done;
        }
        case 16: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,22,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6856 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 593 OMC_FILE
          goto tmp3_done;
        }
        case 17: {
          
          /* Pattern matching succeeded */
#line 6857 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 601 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  if (out_b) { *out_b = _b; }
  return _e;
}

Here is the caller graph for this function:

omc_Absyn_isModificationOfPath()

DLLExport modelica_boolean omc_Absyn_isModificationOfPath	(	threadData_t *	threadData,
		modelica_metatype	_mod,
		modelica_metatype	_path
	)

Definition at line 4579 of file Absyn.c.

{
  modelica_boolean _yes;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4586 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _mod;
    tmp4_2 = _path;
    {
      modelica_string _id1 = NULL;
      modelica_string _id2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          
          _id2 = tmpMeta[0];
          _id1 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 5834 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_id1, _id2));
#line 4612 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 4620 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _yes = tmp1;
  _return: OMC_LABEL_UNUSED
  return _yes;
}

Here is the caller graph for this function:

omc_Absyn_isNotInnerOuter()

DLLExport modelica_boolean omc_Absyn_isNotInnerOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8473 of file Absyn.c.

{
  modelica_boolean _outIsNotInnerOuter;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8479 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inIO;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8494 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4895 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8502 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsNotInnerOuter = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsNotInnerOuter;
}

Here is the caller graph for this function:

omc_Absyn_isOnlyInner()

DLLExport modelica_boolean omc_Absyn_isOnlyInner	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8644 of file Absyn.c.

{
  modelica_boolean _outOnlyInner;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8650 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inIO;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4863 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8665 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4864 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8673 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outOnlyInner = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outOnlyInner;
}

Here is the caller graph for this function:

omc_Absyn_isOnlyOuter()

DLLExport modelica_boolean omc_Absyn_isOnlyOuter	(	threadData_t *	threadData,
		modelica_metatype	_inIO
	)

Definition at line 8587 of file Absyn.c.

{
  modelica_boolean _outOnlyOuter;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8593 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inIO;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4874 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8608 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8616 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outOnlyOuter = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outOnlyOuter;
}

Here is the caller graph for this function:

omc_Absyn_isOuter()

DLLExport modelica_boolean omc_Absyn_isOuter	(	threadData_t *	threadData,
		modelica_metatype	_io
	)

Definition at line 8765 of file Absyn.c.

{
  modelica_boolean _isItAnOuter;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8771 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _io;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          
          /* Pattern matching succeeded */
#line 4837 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8784 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 4838 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 8792 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 4839 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8801 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _isItAnOuter = tmp1;
  _return: OMC_LABEL_UNUSED
  return _isItAnOuter;
}

Here is the caller graph for this function:

omc_Absyn_isOutput()

DLLExport modelica_boolean omc_Absyn_isOutput	(	threadData_t *	threadData,
		modelica_metatype	_inDirection
	)

Definition at line 6213 of file Absyn.c.

{
  modelica_boolean _outIsOutput;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6219 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inDirection;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 5439 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6232 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          
          /* Pattern matching succeeded */
#line 5440 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6240 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 5441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6249 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsOutput = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsOutput;
}

Here is the caller graph for this function:

omc_Absyn_isPackageRestriction()

DLLExport modelica_boolean omc_Absyn_isPackageRestriction	(	threadData_t *	threadData,
		modelica_metatype	_inRestriction
	)

Definition at line 9645 of file Absyn.c.

{
  modelica_boolean _outIsPackage;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9651 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inRestriction;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9666 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4606 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9674 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsPackage = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsPackage;
}

Here is the caller graph for this function:

omc_Absyn_isParts()

DLLExport modelica_boolean omc_Absyn_isParts	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5413 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5419 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _cl;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,5) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 5435 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 5443 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the caller graph for this function:

omc_Absyn_isTuple()

DLLExport modelica_boolean omc_Absyn_isTuple	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 6749 of file Absyn.c.

{
  modelica_boolean _outIsTuple;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6755 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inExp;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 6771 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 6779 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsTuple = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsTuple;
}

Here is the caller graph for this function:

omc_Absyn_iteratorGuard()

DLLExport modelica_metatype omc_Absyn_iteratorGuard	(	threadData_t *	threadData,
		modelica_metatype	_iterator
	)

Definition at line 13027 of file Absyn.c.

{
  modelica_metatype _guardExp = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _iterator;
#line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _guardExp = tmpMeta[1];
#line 13041 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _guardExp;
}

omc_Absyn_iteratorIndexedCrefsEqual()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_iteratorIndexedCrefsEqual	(	threadData_t *	threadData,
		modelica_metatype	_inCref1,
		modelica_metatype	_inCref2
	)

Definition at line 9189 of file Absyn.c.

{
  modelica_boolean _outEqual;
  modelica_metatype _cr1 = NULL;
  modelica_metatype _cr2 = NULL;
  modelica_integer _idx1;
  modelica_integer _idx2;
  modelica_integer tmp1;
  modelica_integer tmp2;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inCref1;
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp1 = mmc_unbox_integer(tmpMeta[2]);
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _cr1 = tmpMeta[1];
#line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _idx1 = tmp1  /* pattern as ty=Integer */;
#line 9215 OMC_FILE

#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inCref2;
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp2 = mmc_unbox_integer(tmpMeta[2]);
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _cr2 = tmpMeta[1];
#line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _idx2 = tmp2  /* pattern as ty=Integer */;
#line 9231 OMC_FILE

#line 4732 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outEqual = (((modelica_integer)_idx1 == (modelica_integer)_idx2) && omc_Absyn_crefEqual(threadData, _cr1, _cr2));
#line 9235 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outEqual;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_iteratorName()

DLLExport modelica_string omc_Absyn_iteratorName	(	threadData_t *	threadData,
		modelica_metatype	_iterator
	)

Definition at line 13067 of file Absyn.c.

{
  modelica_string _name = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _iterator;
#line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[1];
#line 13081 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _name;
}

omc_Absyn_iteratorRange()

DLLExport modelica_metatype omc_Absyn_iteratorRange	(	threadData_t *	threadData,
		modelica_metatype	_iterator
	)

Definition at line 13047 of file Absyn.c.

{
  modelica_metatype _range = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _iterator;
#line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
#line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _range = tmpMeta[1];
#line 13061 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _range;
}

omc_Absyn_joinCrefs()

DLLExport modelica_metatype omc_Absyn_joinCrefs	(	threadData_t *	threadData,
		modelica_metatype	_inComponentRef1,
		modelica_metatype	_inComponentRef2
	)

Definition at line 10901 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10907 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _inComponentRef1;
    tmp3_2 = _inComponentRef2;
    {
      modelica_string _id = NULL;
      modelica_metatype _sub = NULL;
      modelica_metatype _cr2 = NULL;
      modelica_metatype _cr_1 = NULL;
      modelica_metatype _cr = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          modelica_boolean tmp4;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _id = tmpMeta[1];
          _sub = tmpMeta[2];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp4 = 0; /* begin failure */
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          MMC_TRY_INTERNAL(mmc_jumper)
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            /* Pattern-matching assignment */
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _cr2;
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,1) == 0) goto goto_5;
#line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            
#line 10943 OMC_FILE
            tmp4 = 1;
          goto goto_5;
          goto_5:;
          MMC_CATCH_INTERNAL(mmc_jumper)
          if (tmp4) {goto goto_1;} /* end failure */
#line 4322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _sub, _cr2);
#line 4322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 10953 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _id = tmpMeta[1];
          _sub = tmpMeta[2];
          _cr = tmpMeta[3];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 4325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr_1 = omc_Absyn_joinCrefs(threadData, _cr, _cr2);
#line 10969 OMC_FILE
#line 4326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _sub, _cr_1);
#line 4326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 10974 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _cr = tmpMeta[1];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 4330 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr_1 = omc_Absyn_joinCrefs(threadData, _cr, _cr2);
#line 10986 OMC_FILE
#line 4331 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr_1);
#line 10989 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

Here is the caller graph for this function:

omc_Absyn_joinPaths()

DLLExport modelica_metatype omc_Absyn_joinPaths	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 12781 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12787 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _inPath1;
    tmp3_2 = _inPath2;
    {
      modelica_string _str = NULL;
      modelica_metatype _p2 = NULL;
      modelica_metatype _p_1 = NULL;
      modelica_metatype _p = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _str = tmpMeta[1];
          _p2 = tmp3_2;
          /* Pattern matching succeeded */
#line 3804 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p2);
#line 3804 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12811 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _str = tmpMeta[1];
          _p = tmpMeta[2];
          _p2 = tmp3_2;
          /* Pattern matching succeeded */
#line 3807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p_1 = omc_Absyn_joinPaths(threadData, _p, _p2);
#line 12825 OMC_FILE
#line 3808 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p_1);
#line 3808 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12830 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _p = tmpMeta[1];
          _p2 = tmp3_2;
          /* Pattern matching succeeded */
#line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath1 = _p;
#line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath2 = _p2;
#line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 12850 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          
          _p2 = tmpMeta[1];
          _p = tmp3_1;
          /* Pattern matching succeeded */
#line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath1 = _p;
#line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath2 = _p2;
#line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 12871 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_joinPathsOpt()

DLLExport modelica_metatype omc_Absyn_joinPathsOpt	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 12729 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12735 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath1;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!optionNone(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 3822 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath2;
#line 12751 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3823 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _p, _inPath2);
#line 12761 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

omc_Absyn_joinPathsOptSuffix()

DLLExport modelica_metatype omc_Absyn_joinPathsOptSuffix	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 12677 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12683 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath2;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3836 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _inPath1, _p);
#line 12701 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 3837 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath1;
#line 12709 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_joinWithinPath()

DLLExport modelica_metatype omc_Absyn_joinWithinPath	(	threadData_t *	threadData,
		modelica_metatype	_within_,
		modelica_metatype	_path
	)

Definition at line 7176 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7182 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _within_;
    {
      modelica_metatype _path1 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,0) == 0) goto tmp2_end;
          /* Pattern matching succeeded */
#line 5226 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 7198 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _path1 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5227 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _path1, _path);
#line 7208 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

omc_Absyn_lastClassname()

DLLExport modelica_metatype omc_Absyn_lastClassname	(	threadData_t *	threadData,
		modelica_metatype	_inProgram
	)

Definition at line 10303 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype _lst = NULL;
  modelica_string _id = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inProgram;
#line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _lst = tmpMeta[1];
#line 10319 OMC_FILE

#line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = omc_List_last(threadData, _lst);
#line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _id = tmpMeta[1];
#line 10329 OMC_FILE

#line 4443 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
#line 4443 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outPath = tmpMeta[0];
#line 10335 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_makeClassElement()

DLLExport modelica_metatype omc_Absyn_makeClassElement	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5374 of file Absyn.c.

{
  modelica_metatype _el = NULL;
  modelica_metatype _info = NULL;
  modelica_boolean _fp;
  modelica_integer tmp1;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _cl;
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp1 = mmc_unbox_integer(tmpMeta[1]);
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 8));
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _fp = tmp1  /* pattern as ty=Boolean */;
#line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _info = tmpMeta[2];
#line 5397 OMC_FILE

#line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box3(3, &Absyn_ElementSpec_CLASSDEF__desc, mmc_mk_boolean(0), _cl);
#line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = mmc_mk_box7(3, &Absyn_Element_ELEMENT__desc, mmc_mk_boolean(_fp), mmc_mk_none(), _OMC_LIT7, tmpMeta[0], _info, mmc_mk_none());
#line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = mmc_mk_box2(3, &Absyn_ElementItem_ELEMENTITEM__desc, tmpMeta[1]);
#line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _el = tmpMeta[2];
#line 5407 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _el;
}

omc_Absyn_makeCons()

DLLExport modelica_metatype omc_Absyn_makeCons	(	threadData_t *	threadData,
		modelica_metatype	_e1,
		modelica_metatype	_e2
	)

Definition at line 7625 of file Absyn.c.

{
  modelica_metatype _e = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box3(23, &Absyn_Exp_CONS__desc, _e1, _e2);
#line 5129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = tmpMeta[0];
#line 7635 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _e;
}

omc_Absyn_makeFullyQualified()

DLLExport modelica_metatype omc_Absyn_makeFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 8335 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8341 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 4919 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath;
#line 8357 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _inPath);
#line 4920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 8367 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_makeIdentPathFromString()

DLLExport modelica_metatype omc_Absyn_makeIdentPathFromString	(	threadData_t *	threadData,
		modelica_string	_s
	)

Definition at line 18229 of file Absyn.c.

{
  modelica_metatype _p = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s);
#line 2412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p = tmpMeta[0];
#line 18239 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _p;
}

Here is the caller graph for this function:

omc_Absyn_makeNotFullyQualified()

DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 8283 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8289 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_metatype _path = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4931 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 8307 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 4932 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath;
#line 8315 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_makeQualifiedPathFromStrings()

DLLExport modelica_metatype omc_Absyn_makeQualifiedPathFromStrings	(	threadData_t *	threadData,
		modelica_string	_s1,
		modelica_string	_s2
	)

Definition at line 18211 of file Absyn.c.

{
  modelica_metatype _p = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s2);
#line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _s1, tmpMeta[0]);
#line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p = tmpMeta[1];
#line 18223 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _p;
}

omc_Absyn_makeSubscript()

DLLExport modelica_metatype omc_Absyn_makeSubscript	(	threadData_t *	threadData,
		modelica_metatype	_inExp
	)

Definition at line 2075 of file Absyn.c.

{
  modelica_metatype _outSubscript = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Subscript_SUBSCRIPT__desc, _inExp);
#line 6571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outSubscript = tmpMeta[0];
#line 2085 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outSubscript;
}

omc_Absyn_mapCrefParts()

DLLExport modelica_metatype omc_Absyn_mapCrefParts	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_fnptr	_inMapFunc
	)

Definition at line 3462 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3468 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      modelica_string _name = NULL;
      modelica_metatype _subs = NULL;
      modelica_metatype _rest_cref = NULL;
      modelica_metatype _cref = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          _name = tmpMeta[1];
          _subs = tmpMeta[2];
          _rest_cref = tmpMeta[3];
          /* Pattern matching succeeded */
#line 6148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _name, _subs);
#line 6148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = tmpMeta[1];
#line 3493 OMC_FILE

#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))), _cref) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, _cref);
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _name = tmpMeta[2];
#line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _subs = tmpMeta[3];
#line 3509 OMC_FILE

#line 6150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _rest_cref = omc_Absyn_mapCrefParts(threadData, _rest_cref, ((modelica_fnptr) _inMapFunc));
#line 3513 OMC_FILE
#line 6151 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _name, _subs, _rest_cref);
#line 6151 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3518 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 6156 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref = omc_Absyn_mapCrefParts(threadData, _cref, ((modelica_fnptr) _inMapFunc));
#line 3528 OMC_FILE
#line 6157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _cref);
#line 6157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3533 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 6162 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))), _inCref) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, _inCref);
#line 3542 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

omc_Absyn_mergeAnnotations()

DLLExport modelica_metatype omc_Absyn_mergeAnnotations	(	threadData_t *	threadData,
		modelica_metatype	_inAnnotation1,
		modelica_metatype	_inAnnotation2
	)

Definition at line 4845 of file Absyn.c.

{
  modelica_metatype _outAnnotation = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4851 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _inAnnotation1;
    tmp3_2 = _inAnnotation2;
    {
      modelica_metatype _oldmods = NULL;
      modelica_metatype _newmods = NULL;
      modelica_metatype _a = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (!listEmpty(tmpMeta[1])) goto tmp2_end;
          
          _a = tmp3_2;
          /* Pattern matching succeeded */
#line 5767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _a;
#line 4873 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          _oldmods = tmpMeta[1];
          _newmods = tmpMeta[2];
          /* Pattern matching succeeded */
#line 5770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(3, &Absyn_Annotation_ANNOTATION__desc, omc_Absyn_mergeAnnotations2(threadData, _oldmods, _newmods));
#line 5770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 4886 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outAnnotation = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outAnnotation;
}

omc_Absyn_mergeAnnotations2()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_mergeAnnotations2	(	threadData_t *	threadData,
		modelica_metatype	_oldmods,
		modelica_metatype	_newmods
	)

Definition at line 4733 of file Absyn.c.

{
  modelica_metatype _res = NULL;
  modelica_metatype _mods = NULL;
  modelica_boolean _b;
  modelica_metatype _p = NULL;
  modelica_metatype _mod1 = NULL;
  modelica_metatype _mod2 = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _res = listReverse(_oldmods);
#line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _mod;
#line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    for (tmpMeta[0] = _newmods; !listEmpty(tmpMeta[0]); tmpMeta[0]=MMC_CDR(tmpMeta[0]))
#line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    {
#line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      _mod = MMC_CAR(tmpMeta[0]);
#line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      /* Pattern-matching assignment */
#line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      tmpMeta[1] = _mod;
#line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,6) == 0) MMC_THROW_INTERNAL();
#line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
#line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      _p = tmpMeta[2];
#line 4765 OMC_FILE

#line 4767 OMC_FILE
      { /* matchcontinue expression */
        {
          volatile mmc_switch_type tmp3;
          int tmp4;
          tmp3 = 0;
          MMC_TRY_INTERNAL(mmc_jumper)
          tmp2_top:
          threadData->mmc_jumper = &new_mmc_jumper;
          for (; tmp3 < 2; tmp3++) {
            switch (MMC_SWITCH_CAST(tmp3)) {
            case 0: {
              modelica_boolean tmp5;
              /* Pattern matching succeeded */
#line 5789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[1] = mmc_mk_box1(0, _p);
#line 5789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _mod2 = omc_List_find(threadData, _res, (modelica_fnptr) mmc_mk_box2(0,closure4_Absyn_isModificationOfPath,tmpMeta[1]));
#line 4785 OMC_FILE

#line 5790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _mod1 = omc_Absyn_subModsInSameOrder(threadData, _mod2, _mod);
#line 4789 OMC_FILE

#line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              /* Pattern-matching tuple assignment */
#line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[1] = mmc_mk_box1(0, _p);
#line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = omc_List_replaceOnTrue(threadData, _mod1, _res, (modelica_fnptr) mmc_mk_box2(0,closure5_Absyn_isModificationOfPath,tmpMeta[1]), &tmp5);
#line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _res = tmpMeta[2];
#line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (1 != tmp5) goto goto_1;
#line 4801 OMC_FILE
#line 4802 OMC_FILE
              goto tmp2_done;
            }
            case 1: {
              /* Pattern matching succeeded */
#line 5793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[1] = mmc_mk_cons(_mod, _res);
#line 5793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _res = tmpMeta[1];
#line 4811 OMC_FILE
#line 4812 OMC_FILE
              goto tmp2_done;
            }
            }
            goto tmp2_end;
            tmp2_end: ;
          }
          goto goto_1;
          tmp2_done:
          (void)tmp3;
          MMC_RESTORE_INTERNAL(mmc_jumper);
          goto tmp2_done2;
          goto_1:;
          MMC_CATCH_INTERNAL(mmc_jumper);
          if (++tmp3 < 2) {
            goto tmp2_top;
          }
          MMC_THROW_INTERNAL();
          tmp2_done2:;
        }
      }
      ;
    }
  }

#line 5796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _res = listReverse(_res);
#line 4839 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _res;
}

Here is the call graph for this function:

omc_Absyn_mergeCommentAnnotation()

DLLExport modelica_metatype omc_Absyn_mergeCommentAnnotation	(	threadData_t *	threadData,
		modelica_metatype	_inAnnotation,
		modelica_metatype	_inComment
	)

Definition at line 4648 of file Absyn.c.

{
  modelica_metatype _outComment = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4654 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inComment;
    {
      modelica_metatype _ann = NULL;
      modelica_metatype _cmt = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!optionNone(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 5812 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(_inAnnotation), mmc_mk_none());
#line 5812 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
#line 4673 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (!optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
          _cmt = tmpMeta[3];
          /* Pattern matching succeeded */
#line 5816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(_inAnnotation), _cmt);
#line 5816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
#line 4688 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (optionNone(tmpMeta[2])) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
          _ann = tmpMeta[3];
          _cmt = tmpMeta[4];
          /* Pattern matching succeeded */
#line 5820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(omc_Absyn_mergeAnnotations(threadData, _ann, _inAnnotation)), _cmt);
#line 5820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
#line 4705 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComment = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComment;
}

omc_Absyn_onlyLiteralsInAnnotationMod()

DLLExport modelica_boolean omc_Absyn_onlyLiteralsInAnnotationMod	(	threadData_t *	threadData,
		modelica_metatype	_inMod
	)

Definition at line 7927 of file Absyn.c.

{
  modelica_boolean _onlyLiterals;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7934 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;
    tmp4_1 = _inMod;
    {
      modelica_metatype _dive = NULL;
      modelica_metatype _rest = NULL;
      modelica_metatype _eqMod = NULL;
      modelica_boolean _b1;
      modelica_boolean _b2;
      modelica_boolean _b3;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 5; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (!listEmpty(tmp4_1)) goto tmp3_end;
          tmp4 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 4994 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7958 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[0] = MMC_CAR(tmp4_1);
          tmpMeta[1] = MMC_CDR(tmp4_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          if (11 != MMC_STRLEN(tmpMeta[3]) || strcmp(MMC_STRINGDATA(_OMC_LIT31), MMC_STRINGDATA(tmpMeta[3])) != 0) goto tmp3_end;
          
          _rest = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4999 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
#line 7975 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[0] = MMC_CAR(tmp4_1);
          tmpMeta[1] = MMC_CDR(tmp4_1);
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
          if (optionNone(tmpMeta[2])) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
          
          _dive = tmpMeta[4];
          _eqMod = tmpMeta[5];
          _rest = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5007 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b1 = omc_Absyn_onlyLiteralsInEqMod(threadData, _eqMod);
#line 7995 OMC_FILE

#line 5008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b2 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _dive);
#line 7999 OMC_FILE

#line 5009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b3 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
#line 8003 OMC_FILE
#line 5010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (_b1 && (_b2 && _b3));
#line 8006 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (listEmpty(tmp4_1)) goto tmp3_end;
          tmpMeta[0] = MMC_CAR(tmp4_1);
          tmpMeta[1] = MMC_CDR(tmp4_1);
          _rest = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5016 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
#line 8017 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 5021 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 8025 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 5) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _onlyLiterals = tmp1;
  _return: OMC_LABEL_UNUSED
  return _onlyLiterals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_onlyLiteralsInEqMod()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_onlyLiteralsInEqMod	(	threadData_t *	threadData,
		modelica_metatype	_eqMod
	)

Definition at line 7834 of file Absyn.c.

{
  modelica_boolean _onlyLiterals;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7841 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _eqMod;
    {
      modelica_metatype _exp = NULL;
      modelica_metatype _lst = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5038 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7858 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],11,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          if (13 != MMC_STRLEN(tmpMeta[2]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[2])) != 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7873 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _exp = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching tuple assignment, wild first pattern */
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_Absyn_traverseExpBidir(threadData, _exp, boxvar_Absyn_onlyLiteralsInExpEnter, boxvar_Absyn_onlyLiteralsInExpExit, _OMC_LIT30, &tmpMeta[0]);
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (listEmpty(tmpMeta[0])) goto goto_2;
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_CAR(tmpMeta[0]);
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_CDR(tmpMeta[0]);
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (!listEmpty(tmpMeta[2])) goto goto_2;
#line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _lst = tmpMeta[1];
#line 7896 OMC_FILE
#line 5048 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = listEmpty(_lst);
#line 7899 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _onlyLiterals = tmp1;
  _return: OMC_LABEL_UNUSED
  return _onlyLiterals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_onlyLiteralsInExpEnter()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpEnter	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inLst,
		modelica_metatype *	out_outLst
	)

Definition at line 7710 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outLst = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5065 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5065 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 7721 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inExp;
    tmp4_2 = _inLst;
    {
      modelica_boolean _b;
      modelica_metatype _e = NULL;
      modelica_metatype _lst = NULL;
      modelica_metatype _rest = NULL;
      modelica_string _name = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 4; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],2,2) == 0) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          if (13 != MMC_STRLEN(tmpMeta[3]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[3])) != 0) goto tmp3_end;
          
          _rest = tmp4_2;
          /* Pattern matching succeeded */
#line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(tmpMeta[3], _rest);
#line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[2];
#line 7754 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (listEmpty(tmp4_2)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_2);
          tmpMeta[3] = MMC_CDR(tmp4_2);
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,3) == 0) goto tmp3_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
          
          _lst = tmpMeta[2];
          _rest = tmpMeta[3];
          _e = tmp4_1;
          _name = tmpMeta[5];
          /* Pattern matching succeeded */
#line 5082 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b = listMember(_name, _OMC_LIT29);
#line 7773 OMC_FILE

#line 5090 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _lst = omc_List_consOnTrue(threadData, (!_b), _e, _lst);
#line 7777 OMC_FILE
#line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(_lst, _rest);
#line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[2];
#line 7784 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          if (listEmpty(tmp4_2)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_2);
          tmpMeta[3] = MMC_CDR(tmp4_2);
          _lst = tmpMeta[2];
          _rest = tmpMeta[3];
          /* Pattern matching succeeded */
#line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = mmc_mk_cons(_inExp, _lst);
#line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(tmpMeta[3], _rest);
#line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[2];
#line 7803 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 5096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inLst;
#line 7813 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outExp = tmpMeta[0+0];
  _outLst = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outLst) { *out_outLst = _outLst; }
  return _outExp;
}

omc_Absyn_onlyLiteralsInExpExit()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpExit	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inLst,
		modelica_metatype *	out_outLst
	)

Definition at line 7640 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outLst = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 5110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 7651 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inExp;
    tmp4_2 = _inLst;
    {
      modelica_metatype _lst = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (listEmpty(tmp4_2)) goto tmp3_end;
          tmpMeta[2] = MMC_CAR(tmp4_2);
          tmpMeta[3] = MMC_CDR(tmp4_2);
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],2,2) == 0) goto tmp3_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
          if (13 != MMC_STRLEN(tmpMeta[5]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[5])) != 0) goto tmp3_end;
          
          _lst = tmpMeta[3];
          /* Pattern matching succeeded */
#line 5116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _lst;
#line 7679 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 5119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inLst;
#line 7689 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outExp = tmpMeta[0+0];
  _outLst = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outLst) { *out_outLst = _outLst; }
  return _outExp;
}

omc_Absyn_opEqual()

DLLExport modelica_boolean omc_Absyn_opEqual	(	threadData_t *	threadData,
		modelica_metatype	_op1,
		modelica_metatype	_op2
	)

Definition at line 3441 of file Absyn.c.

{
  modelica_boolean _isEqual;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6174 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _isEqual = valueEq(_op1, _op2);
#line 3448 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _isEqual;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_opIsElementWise()

DLLExport modelica_boolean omc_Absyn_opIsElementWise	(	threadData_t *	threadData,
		modelica_metatype	_op
	)

Definition at line 3337 of file Absyn.c.

{
  modelica_boolean _isElementWise;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3343 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _op;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 10: {
          
          /* Pattern matching succeeded */
#line 6182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3356 OMC_FILE
          goto tmp3_done;
        }
        case 11: {
          
          /* Pattern matching succeeded */
#line 6183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3364 OMC_FILE
          goto tmp3_done;
        }
        case 12: {
          
          /* Pattern matching succeeded */
#line 6184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3372 OMC_FILE
          goto tmp3_done;
        }
        case 13: {
          
          /* Pattern matching succeeded */
#line 6185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3380 OMC_FILE
          goto tmp3_done;
        }
        case 14: {
          
          /* Pattern matching succeeded */
#line 6186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3388 OMC_FILE
          goto tmp3_done;
        }
        case 15: {
          
          /* Pattern matching succeeded */
#line 6187 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3396 OMC_FILE
          goto tmp3_done;
        }
        case 16: {
          
          /* Pattern matching succeeded */
#line 6188 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 3404 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 6189 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 3413 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _isElementWise = tmp1;
  _return: OMC_LABEL_UNUSED
  return _isElementWise;
}

Here is the caller graph for this function:

omc_Absyn_optArrayDimEqual()

DLLExport modelica_boolean omc_Absyn_optArrayDimEqual	(	threadData_t *	threadData,
		modelica_metatype	_oad1,
		modelica_metatype	_oad2
	)

Definition at line 17375 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17382 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _oad1;
    tmp4_2 = _oad2;
    {
      modelica_metatype _ad1 = NULL;
      modelica_metatype _ad2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          if (optionNone(tmp4_1)) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
          if (optionNone(tmp4_2)) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 1));
          _ad1 = tmpMeta[0];
          _ad2 = tmpMeta[1];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = omc_List_isEqualOnTrue(threadData, _ad1, _ad2, boxvar_Absyn_subscriptEqual);
#line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 17413 OMC_FILE
#line 2616 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 17416 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (!optionNone(tmp4_1)) goto tmp3_end;
          if (!optionNone(tmp4_2)) goto tmp3_end;
          /* Pattern matching succeeded */
#line 2617 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 17425 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 2618 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 17433 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 3) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_optMsg()

DLLExport modelica_metatype omc_Absyn_optMsg	(	threadData_t *	threadData,
		modelica_boolean	_inShowMessage,
		modelica_metatype	_inInfo
	)

Definition at line 2091 of file Absyn.c.

{
  modelica_metatype _outMsg = NULL;
  modelica_boolean tmp1;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp1 = (modelica_boolean)_inShowMessage;
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if(tmp1)
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[0] = mmc_mk_box2(3, &Absyn_Msg_MSG__desc, _inInfo);
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = tmpMeta[0];
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  else
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = _OMC_LIT0;
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outMsg = tmpMeta[1];
#line 2120 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outMsg;
}

Here is the caller graph for this function:

omc_Absyn_optPathString()

DLLExport modelica_string omc_Absyn_optPathString	(	threadData_t *	threadData,
		modelica_metatype	_inPathOption
	)

Definition at line 16185 of file Absyn.c.

{
  modelica_string _outString = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 16192 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPathOption;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (!optionNone(tmp4_1)) goto tmp3_end;
          /* Pattern matching succeeded */
#line 2838 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT2;
#line 16208 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (optionNone(tmp4_1)) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
#line 16218 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outString = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the call graph for this function:

omc_Absyn_pathAppendList()

DLLExport modelica_metatype omc_Absyn_pathAppendList	(	threadData_t *	threadData,
		modelica_metatype	_inPathLst
	)

Definition at line 12550 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12556 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPathLst;
    {
      modelica_metatype _path = NULL;
      modelica_metatype _first = NULL;
      modelica_metatype _rest = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 3865 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _OMC_LIT52;
#line 12574 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          if (!listEmpty(tmpMeta[2])) goto tmp2_end;
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3866 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 12586 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          _first = tmpMeta[1];
          _rest = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = omc_Absyn_pathAppendList(threadData, _rest);
#line 12598 OMC_FILE
#line 3870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _first, _path);
#line 12601 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathCompare()

DLLExport modelica_integer omc_Absyn_pathCompare	(	threadData_t *	threadData,
		modelica_metatype	_ip1,
		modelica_metatype	_ip2
	)

Definition at line 16507 of file Absyn.c.

{
  modelica_integer _o;
  modelica_integer tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 16514 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _ip1;
    tmp4_2 = _ip2;
    {
      modelica_metatype _p1 = NULL;
      modelica_metatype _p2 = NULL;
      modelica_string _i1 = NULL;
      modelica_string _i2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 7; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _p1 = tmpMeta[0];
          _p2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip1 = _p1;
#line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip2 = _p2;
#line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 16547 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2765 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) 1);
#line 16556 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) -1);
#line 16565 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          modelica_boolean tmp6;
          modelica_integer tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _i1 = tmpMeta[0];
          _p1 = tmpMeta[1];
          _i2 = tmpMeta[2];
          _p2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 2769 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _o = stringCompare(_i1, _i2);
#line 16584 OMC_FILE
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)((modelica_integer)_o == ((modelica_integer) 0));
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            /* Tail recursive call */
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _ip1 = _p1;
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _ip2 = _p2;
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            goto _tailrecursive;
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            /* TODO: Make sure any eventual dead code below is never generated */
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp7 = (modelica_integer)_o;
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = tmp7;
#line 16613 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2772 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) 1);
#line 16622 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2773 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) -1);
#line 16631 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _i1 = tmpMeta[0];
          _i2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = stringCompare(_i1, _i2);
#line 16644 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _o = tmp1;
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the caller graph for this function:

omc_Absyn_pathCompareNoQual()

DLLExport modelica_integer omc_Absyn_pathCompareNoQual	(	threadData_t *	threadData,
		modelica_metatype	_ip1,
		modelica_metatype	_ip2
	)

Definition at line 16369 of file Absyn.c.

{
  modelica_integer _o;
  modelica_integer tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 16376 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _ip1;
    tmp4_2 = _ip2;
    {
      modelica_metatype _p1 = NULL;
      modelica_metatype _p2 = NULL;
      modelica_string _i1 = NULL;
      modelica_string _i2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 6; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _p1 = tmpMeta[0];
          _p2 = tmp4_2;
          /* Pattern matching succeeded */
#line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip1 = _p1;
#line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip2 = _p2;
#line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 16408 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _p2 = tmpMeta[0];
          _p1 = tmp4_1;
          /* Pattern matching succeeded */
#line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip1 = _p1;
#line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ip2 = _p2;
#line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 16428 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _i1 = tmpMeta[0];
          _p1 = tmpMeta[1];
          _i2 = tmpMeta[2];
          _p2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 2792 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _o = stringCompare(_i1, _i2);
#line 16445 OMC_FILE
#line 2793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (((modelica_integer)_o == ((modelica_integer) 0))?omc_Absyn_pathCompare(threadData, _p1, _p2):(modelica_integer)_o);
#line 16448 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) 1);
#line 16457 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) -1);
#line 16466 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _i1 = tmpMeta[0];
          _i2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = stringCompare(_i1, _i2);
#line 16479 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _o = tmp1;
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathContainedIn()

DLLExport modelica_metatype omc_Absyn_pathContainedIn	(	threadData_t *	threadData,
		modelica_metatype	_subPath,
		modelica_metatype	_path
	)

Definition at line 13843 of file Absyn.c.

{
  modelica_metatype _completePath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 13849 OMC_FILE
  { /* matchcontinue expression */
    {
      modelica_string _ident = NULL;
      modelica_metatype _newPath = NULL;
      modelica_metatype _newSubPath = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          modelica_boolean tmp5;
          /* Pattern matching succeeded */
#line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = omc_Absyn_pathSuffixOf(threadData, _subPath, _path);
#line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 13872 OMC_FILE
#line 3483 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 13875 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          /* Pattern matching succeeded */
#line 3488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ident = omc_Absyn_pathLastIdent(threadData, _path);
#line 13882 OMC_FILE

#line 3489 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _newPath = omc_Absyn_stripLast(threadData, _path);
#line 13886 OMC_FILE

#line 3490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _newPath = omc_Absyn_pathContainedIn(threadData, _subPath, _newPath);
#line 13890 OMC_FILE
#line 3491 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _ident);
#line 3491 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _newPath, tmpMeta[1]);
#line 13895 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          /* Pattern matching succeeded */
#line 3496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ident = omc_Absyn_pathLastIdent(threadData, _subPath);
#line 13902 OMC_FILE

#line 3497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _newSubPath = omc_Absyn_stripLast(threadData, _subPath);
#line 13906 OMC_FILE

#line 3498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _newSubPath = omc_Absyn_pathContainedIn(threadData, _newSubPath, _path);
#line 13910 OMC_FILE
#line 3499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _ident);
#line 3499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _newSubPath, tmpMeta[1]);
#line 13915 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 3) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _completePath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _completePath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathContains()

DLLExport modelica_boolean omc_Absyn_pathContains	(	threadData_t *	threadData,
		modelica_metatype	_fullPath,
		modelica_metatype	_pathId
	)

Definition at line 14041 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14048 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _fullPath;
    tmp4_2 = _pathId;
    {
      modelica_string _str1 = NULL;
      modelica_string _str2 = NULL;
      modelica_metatype _qp = NULL;
      modelica_boolean _b1;
      modelica_boolean _b2;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _str1 = tmpMeta[0];
          _str2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_str1, _str2));
#line 14072 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _str1 = tmpMeta[0];
          _qp = tmpMeta[1];
          _str2 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b1 = (stringEqual(_str1, _str2));
#line 14087 OMC_FILE

#line 3423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b2 = omc_Absyn_pathContains(threadData, _qp, _pathId);
#line 14091 OMC_FILE
#line 3424 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (_b1 || _b2);
#line 14094 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _qp = tmpMeta[0];
          /* Pattern matching succeeded */
#line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fullPath = _qp;
#line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14111 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathContainsString()

DLLExport modelica_boolean omc_Absyn_pathContainsString	(	threadData_t *	threadData,
		modelica_metatype	_p1,
		modelica_string	_str
	)

Definition at line 13942 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 13949 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_string tmp4_2;
    tmp4_1 = _p1;
    tmp4_2 = _str;
    {
      modelica_string _str1 = NULL;
      modelica_string _searchStr = NULL;
      modelica_metatype _qp = NULL;
      modelica_boolean _b1;
      modelica_boolean _b2;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _str1 = tmpMeta[0];
          _searchStr = tmp4_2;
          /* Pattern matching succeeded */
#line 3447 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (omc_System_stringFind(threadData, _str1, _searchStr) != ((modelica_integer) -1));
#line 13972 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _str1 = tmpMeta[0];
          _qp = tmpMeta[1];
          _searchStr = tmp4_2;
          /* Pattern matching succeeded */
#line 3452 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b1 = (omc_System_stringFind(threadData, _str1, _searchStr) != ((modelica_integer) -1));
#line 13986 OMC_FILE

#line 3453 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _b2 = omc_Absyn_pathContainsString(threadData, _qp, _searchStr);
#line 13990 OMC_FILE
#line 3454 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (_b1 || _b2);
#line 13993 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _qp = tmpMeta[0];
          _searchStr = tmp4_2;
          /* Pattern matching succeeded */
#line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p1 = _qp;
#line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str = _searchStr;
#line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14013 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathEqual()

DLLExport modelica_boolean omc_Absyn_pathEqual	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 17616 of file Absyn.c.

{
  modelica_boolean _outBoolean;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17623 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inPath1;
    tmp4_2 = _inPath2;
    {
      modelica_string _id1 = NULL;
      modelica_string _id2 = NULL;
      modelica_metatype _path1 = NULL;
      modelica_metatype _path2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 5; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _path1 = tmpMeta[0];
          _path2 = tmp4_2;
          /* Pattern matching succeeded */
#line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath1 = _path1;
#line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath2 = _path2;
#line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 17655 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _path2 = tmpMeta[0];
          _path1 = tmp4_1;
          /* Pattern matching succeeded */
#line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath1 = _path1;
#line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath2 = _path2;
#line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 17675 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _id1 = tmpMeta[0];
          _id2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2562 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_id1, _id2));
#line 17688 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          modelica_boolean tmp6;
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _id1 = tmpMeta[0];
          _path1 = tmpMeta[1];
          _id2 = tmpMeta[2];
          _path2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)(stringEqual(_id1, _id2));
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            /* Tail recursive call */
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _inPath1 = _path1;
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _inPath2 = _path2;
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            goto _tailrecursive;
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            /* TODO: Make sure any eventual dead code below is never generated */
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp7 = 0;
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = tmp7;
#line 17733 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 2569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 17741 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outBoolean = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outBoolean;
}

Here is the caller graph for this function:

omc_Absyn_pathFirstIdent()

DLLExport modelica_string omc_Absyn_pathFirstIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15652 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15659 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      modelica_string _n = NULL;
      modelica_metatype _p = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15682 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _n = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 15693 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _n = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2990 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 15703 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

Here is the caller graph for this function:

omc_Absyn_pathFirstPath()

DLLExport modelica_metatype omc_Absyn_pathFirstPath	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15583 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15589 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_string _n = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 3002 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath;
#line 15603 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3003 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _n);
#line 3003 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 15616 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _outPath = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _outPath;
#line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15632 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_pathGe()

DLLExport modelica_boolean omc_Absyn_pathGe	(	threadData_t *	threadData,
		modelica_metatype	_path1,
		modelica_metatype	_path2
	)

Definition at line 6017 of file Absyn.c.

{
  modelica_boolean _ge;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5485 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _ge = (!omc_Absyn_pathLt(threadData, _path1, _path2));
#line 6024 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _ge;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathHashMod()

DLLExport modelica_integer omc_Absyn_pathHashMod	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_integer	_mod
	)

Definition at line 16346 of file Absyn.c.

{
  modelica_integer _hash;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _hash = labs(modelica_integer_mod(omc_Absyn_pathHashModWork(threadData, _path, ((modelica_integer) 5381)), (modelica_integer)_mod));
#line 16353 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _hash;
}

Here is the caller graph for this function:

omc_Absyn_pathHashModWork()

DLLExport modelica_integer omc_Absyn_pathHashModWork	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_integer	_acc
	)

Definition at line 16238 of file Absyn.c.

{
  modelica_integer _hash;
  modelica_integer tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 16245 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _path;
    {
      modelica_metatype _p = NULL;
      modelica_string _s = NULL;
      modelica_integer _i;
      modelica_integer _i2;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p;
#line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _acc = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
#line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 16272 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          _s = tmpMeta[0];
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _i = stringHashDjb2(_s);
#line 16284 OMC_FILE

#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _i2 = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
#line 16288 OMC_FILE
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p;
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _acc = (((modelica_integer) 31)) * ((modelica_integer)_i2) + (modelica_integer)_i;
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 16299 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _s = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _i = stringHashDjb2(_s);
#line 16309 OMC_FILE

#line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _i2 = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
#line 16313 OMC_FILE
#line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (((modelica_integer) 31)) * ((modelica_integer)_i2) + (modelica_integer)_i;
#line 16316 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _hash = tmp1;
  _return: OMC_LABEL_UNUSED
  return _hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathIsFullyQualified()

DLLExport modelica_boolean omc_Absyn_pathIsFullyQualified	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7476 of file Absyn.c.

{
  modelica_boolean _outIsQualified;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7482 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7498 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5168 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 7506 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsQualified = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsQualified;
}

Here is the caller graph for this function:

omc_Absyn_pathIsIdent()

DLLExport modelica_boolean omc_Absyn_pathIsIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7418 of file Absyn.c.

{
  modelica_boolean _outIsIdent;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7424 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7440 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 7448 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsIdent;
}

Here is the caller graph for this function:

omc_Absyn_pathIsQual()

DLLExport modelica_boolean omc_Absyn_pathIsQual	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7360 of file Absyn.c.

{
  modelica_boolean _outIsQual;
  modelica_boolean tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7366 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 5187 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7382 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5188 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 7390 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsQual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsQual;
}

Here is the caller graph for this function:

omc_Absyn_pathLast()

DLLExport modelica_metatype omc_Absyn_pathLast	(	threadData_t *	threadData,
		modelica_metatype _	$in_path
	)

Definition at line 15723 of file Absyn.c.

{
  modelica_metatype _path = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _path = _$in_path;
#line 15730 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _path;
    {
      modelica_metatype _p = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _$in_path = _p;
#line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15752 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 2974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _path;
#line 15760 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _$in_path = _p;
#line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15776 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _path = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _path;
}

omc_Absyn_pathLastIdent()

DLLExport modelica_string omc_Absyn_pathLastIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15796 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15803 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      modelica_string _id = NULL;
      modelica_metatype _p = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15826 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _id = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2961 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _id;
#line 15836 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15852 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

Here is the caller graph for this function:

omc_Absyn_pathLt()

DLLExport modelica_boolean omc_Absyn_pathLt	(	threadData_t *	threadData,
		modelica_metatype	_path1,
		modelica_metatype	_path2
	)

Definition at line 6038 of file Absyn.c.

{
  modelica_boolean _lt;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5477 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _lt = (stringCompare(omc_Absyn_pathString(threadData, _path1, _OMC_LIT1, 1, 0), omc_Absyn_pathString(threadData, _path2, _OMC_LIT1, 1, 0)) < ((modelica_integer) 0));
#line 6045 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _lt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathPartCount()

DLLExport modelica_integer omc_Absyn_pathPartCount	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_integer	_partsAccum
	)

Definition at line 329 of file Absyn.c.

{
  modelica_integer _parts;
  modelica_integer tmp1 = 0;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 335 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _path;
    {
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 6868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = ((modelica_integer) 1) + (modelica_integer)_partsAccum;
#line 348 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_path), 3)));
#line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _partsAccum = ((modelica_integer) 1) + (modelica_integer)_partsAccum;
#line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 364 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          
          /* Pattern matching succeeded */
#line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_path), 2)));
#line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _partsAccum = (modelica_integer)_partsAccum;
#line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 380 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _parts = tmp1;
  _return: OMC_LABEL_UNUSED
  return _parts;
}

Here is the caller graph for this function:

omc_Absyn_pathPrefix()

DLLExport modelica_metatype omc_Absyn_pathPrefix	(	threadData_t *	threadData,
		modelica_metatype	_path
	)

Definition at line 15277 of file Absyn.c.

{
  modelica_metatype _prefix = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15283 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;
    tmp3_1 = _path;
    {
      modelica_metatype _p = NULL;
      modelica_string _n = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3069 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_pathPrefix(threadData, _p);
#line 15305 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp2_end;
          
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _n);
#line 3070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 15320 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _n = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3073 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_pathPrefix(threadData, _p);
#line 15332 OMC_FILE
#line 3074 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
#line 3074 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 15337 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 3) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _prefix = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _prefix;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathPrefixOf()

DLLExport modelica_boolean omc_Absyn_pathPrefixOf	(	threadData_t *	threadData,
		modelica_metatype	_prefixPath,
		modelica_metatype	_path
	)

Definition at line 14548 of file Absyn.c.

{
  modelica_boolean _isPrefix;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14555 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _prefixPath;
    tmp4_2 = _path;
    {
      modelica_metatype _p = NULL;
      modelica_metatype _p2 = NULL;
      modelica_string _id = NULL;
      modelica_string _id2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 6; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _p = tmpMeta[0];
          _p2 = tmp4_2;
          /* Pattern matching succeeded */
#line 3271 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
#line 14582 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _p2 = tmpMeta[0];
          _p = tmp4_1;
          tmp4 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
#line 14594 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _id = tmpMeta[0];
          _id2 = tmpMeta[1];
          tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_id, _id2));
#line 14607 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          
          _id = tmpMeta[0];
          _id2 = tmpMeta[1];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = (stringEqual(_id, _id2));
#line 14621 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          modelica_boolean tmp6;
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _id = tmpMeta[0];
          _p = tmpMeta[1];
          _id2 = tmpMeta[2];
          _p2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id, _id2));
#line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 14644 OMC_FILE

#line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
#line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_2;
#line 14652 OMC_FILE
#line 3279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 14655 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          
          /* Pattern matching succeeded */
#line 3281 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 14663 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 6) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _isPrefix = tmp1;
  _return: OMC_LABEL_UNUSED
  return _isPrefix;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathReplaceFirstIdent()

DLLExport modelica_metatype omc_Absyn_pathReplaceFirstIdent	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_replPath
	)

Definition at line 14857 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14863 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _path;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3198 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_joinPaths(threadData, _replPath, _p);
#line 14881 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3199 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _replPath;
#line 14890 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

omc_Absyn_pathReplaceIdent()

DLLExport modelica_metatype omc_Absyn_pathReplaceIdent	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_string	_last
	)

Definition at line 8849 of file Absyn.c.

{
  modelica_metatype _out = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 8855 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_string tmp3_2;
    tmp3_1 = _path;
    tmp3_2 = _last;
    {
      modelica_metatype _p = NULL;
      modelica_string _n = NULL;
      modelica_string _s = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _p = tmpMeta[1];
          _s = tmp3_2;
          /* Pattern matching succeeded */
#line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_pathReplaceIdent(threadData, _p, _s);
#line 8876 OMC_FILE
#line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
#line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 8881 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _n = tmpMeta[1];
          _p = tmpMeta[2];
          _s = tmp3_2;
          /* Pattern matching succeeded */
#line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_pathReplaceIdent(threadData, _p, _s);
#line 8895 OMC_FILE
#line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
#line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 8900 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          _s = tmp3_2;
          /* Pattern matching succeeded */
#line 4818 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s);
#line 4818 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 8912 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _out = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathRest()

DLLExport modelica_metatype omc_Absyn_pathRest	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15447 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15453 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _outPath = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3029 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outPath;
#line 15470 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _outPath = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _outPath;
#line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15486 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_pathSecondIdent()

DLLExport modelica_string omc_Absyn_pathSecondIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15506 of file Absyn.c.

{
  modelica_string _outIdent = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15513 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      modelica_string _n = NULL;
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,2) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 15535 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _n;
#line 15547 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15563 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIdent = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIdent;
}

Here is the caller graph for this function:

omc_Absyn_pathSetLastIdent()

DLLExport modelica_metatype omc_Absyn_pathSetLastIdent	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_metatype	_inLastIdent
	)

Definition at line 5279 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5285 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_metatype _p = NULL;
      modelica_string _n = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          
          /* Pattern matching succeeded */
#line 5647 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inLastIdent;
#line 5300 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _n = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 5651 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_pathSetLastIdent(threadData, _p, _inLastIdent);
#line 5312 OMC_FILE
#line 5652 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
#line 5652 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5317 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_pathSetLastIdent(threadData, _p, _inLastIdent);
#line 5327 OMC_FILE
#line 5658 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
#line 5658 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5332 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathString()

DLLExport modelica_string omc_Absyn_pathString	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_string	_delimiter,
		modelica_boolean	_usefq,
		modelica_boolean	_reverse
	)

Definition at line 17021 of file Absyn.c.

{
  modelica_string _s = NULL;
  modelica_metatype _p1 = NULL;
  modelica_metatype _p2 = NULL;
  modelica_integer _count;
  modelica_integer _len;
  modelica_integer _dlen;
  modelica_boolean _b;
  modelica_integer tmp5_c1 __attribute__((unused)) = 0;
  modelica_integer tmp5_c2 __attribute__((unused)) = 0;
  modelica_boolean tmp5_c3 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _count = ((modelica_integer) 0);
  _len = ((modelica_integer) 0);
  _dlen = stringLength(_delimiter);
#line 2672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p1 = (_usefq?_path:omc_Absyn_makeNotFullyQualified(threadData, _path));
#line 17041 OMC_FILE

#line 17043 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _p1;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 2677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _s = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p1), 2)));
#line 17059 OMC_FILE

#line 2678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _return;
#line 17063 OMC_FILE
#line 17064 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 17070 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  ;

#line 2682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p2 = _p1;
#line 17088 OMC_FILE

#line 2683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _b = 1;
#line 17092 OMC_FILE

#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  while(1)
#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if(!_b) break;
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 17108 OMC_FILE
    { /* match expression */
      modelica_metatype tmp8_1;
      tmp8_1 = _p2;
      {
        int tmp8;
        {
          switch (MMC_SWITCH_CAST(valueConstructor(tmp8_1))) {
          case 4: {
            
            /* Pattern matching succeeded */
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = _p2;
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 0;
#line 17127 OMC_FILE
            goto tmp7_done;
          }
          case 3: {
            
            /* Pattern matching succeeded */
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 3)));
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 1;
#line 17141 OMC_FILE
            goto tmp7_done;
          }
          case 5: {
            
            /* Pattern matching succeeded */
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2)));
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count;
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 1;
#line 17155 OMC_FILE
            goto tmp7_done;
          }
          }
          goto tmp7_end;
          tmp7_end: ;
        }
        goto goto_6;
        goto_6:;
        MMC_THROW_INTERNAL();
        goto tmp7_done;
        tmp7_done:;
      }
    }
    _p2 = tmpMeta[0+0];
    _len = tmp5_c1;
    _count = tmp5_c2;
    _b = tmp5_c3;
  }

#line 2691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _s = omc_Absyn_pathStringWork(threadData, _p1, (((modelica_integer) -1) + (modelica_integer)_len) * ((modelica_integer)_dlen) + (modelica_integer)_count, _delimiter, (modelica_integer)_dlen, _reverse);
#line 17177 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathStringDefault()

DLLExport modelica_string omc_Absyn_pathStringDefault	(	threadData_t *	threadData,
		modelica_metatype	_path
	)

Definition at line 16714 of file Absyn.c.

{
  modelica_string _s = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _s = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
  _return: OMC_LABEL_UNUSED
  return _s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathStringNoQual()

DLLExport modelica_string omc_Absyn_pathStringNoQual	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_string	_delimiter,
		modelica_boolean	_usefq,
		modelica_boolean	_reverse
	)

Definition at line 16725 of file Absyn.c.

{
  modelica_string _s = NULL;
  modelica_metatype _p1 = NULL;
  modelica_metatype _p2 = NULL;
  modelica_integer _count;
  modelica_integer _len;
  modelica_integer _dlen;
  modelica_boolean _b;
  modelica_integer tmp5_c1 __attribute__((unused)) = 0;
  modelica_integer tmp5_c2 __attribute__((unused)) = 0;
  modelica_boolean tmp5_c3 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _count = ((modelica_integer) 0);
  _len = ((modelica_integer) 0);
  _dlen = stringLength(_delimiter);
#line 2672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p1 = (_usefq?_path:omc_Absyn_makeNotFullyQualified(threadData, _path));
#line 16745 OMC_FILE

#line 16747 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _p1;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 2677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _s = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p1), 2)));
#line 16763 OMC_FILE

#line 2678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _return;
#line 16767 OMC_FILE
#line 16768 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 16774 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  ;

#line 2682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _p2 = _p1;
#line 16792 OMC_FILE

#line 2683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _b = 1;
#line 16796 OMC_FILE

#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  while(1)
#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if(!_b) break;
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 16812 OMC_FILE
    { /* match expression */
      modelica_metatype tmp8_1;
      tmp8_1 = _p2;
      {
        int tmp8;
        {
          switch (MMC_SWITCH_CAST(valueConstructor(tmp8_1))) {
          case 4: {
            
            /* Pattern matching succeeded */
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = _p2;
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
#line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 0;
#line 16831 OMC_FILE
            goto tmp7_done;
          }
          case 3: {
            
            /* Pattern matching succeeded */
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 3)));
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
#line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 1;
#line 16845 OMC_FILE
            goto tmp7_done;
          }
          case 5: {
            
            /* Pattern matching succeeded */
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2)));
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c2 = (modelica_integer)_count;
#line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5_c3 = 1;
#line 16859 OMC_FILE
            goto tmp7_done;
          }
          }
          goto tmp7_end;
          tmp7_end: ;
        }
        goto goto_6;
        goto_6:;
        MMC_THROW_INTERNAL();
        goto tmp7_done;
        tmp7_done:;
      }
    }
    _p2 = tmpMeta[0+0];
    _len = tmp5_c1;
    _count = tmp5_c2;
    _b = tmp5_c3;
  }

#line 2691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _s = omc_Absyn_pathStringWork(threadData, _p1, (((modelica_integer) -1) + (modelica_integer)_len) * ((modelica_integer)_dlen) + (modelica_integer)_count, _delimiter, (modelica_integer)_dlen, _reverse);
#line 16881 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathStringUnquoteReplaceDot()

DLLExport modelica_string omc_Absyn_pathStringUnquoteReplaceDot	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_string	_repStr
	)

Definition at line 16151 of file Absyn.c.

{
  modelica_string _outString = NULL;
  modelica_metatype _strlst = NULL;
  modelica_string _rep_rep = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = stringAppend(_repStr,_repStr);
#line 2860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _rep_rep = tmpMeta[0];
#line 16163 OMC_FILE

#line 2861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _strlst = omc_Absyn_pathToStringList(threadData, _inPath);
#line 16167 OMC_FILE

#line 2862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _strlst = omc_List_map2(threadData, _strlst, boxvar_System_stringReplace, _repStr, _rep_rep);
#line 16171 OMC_FILE

#line 2863 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _strlst = omc_List_map(threadData, _strlst, boxvar_System_unquoteIdentifier);
#line 16175 OMC_FILE

#line 2864 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outString = stringDelimitList(_strlst, _repStr);
#line 16179 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathStringWork()

PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_integer	_len,
		modelica_string	_delimiter,
		modelica_integer	_dlen,
		modelica_boolean	_reverse
	)

Definition at line 16897 of file Absyn.c.

{
  modelica_string _s = NULL;
  modelica_metatype _p = NULL;
  modelica_boolean _b;
  modelica_integer _count;
  modelica_complex _sb;
  modelica_integer tmp1_c1 __attribute__((unused)) = 0;
  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _s = _OMC_LIT2;
  _p = _inPath;
  _b = 1;
  _count = ((modelica_integer) 0);
  _sb = omc_System_StringAllocator_constructor(threadData, (modelica_integer)_len);
#line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  while(1)
#line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if(!_b) break;
#line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    
#line 16926 OMC_FILE
    { /* match expression */
      modelica_metatype tmp4_1;
      tmp4_1 = _p;
      {
        int tmp4;
        {
          switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
          case 4: {
            
            /* Pattern matching succeeded */
#line 2715 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            omc_System_stringAllocatorStringCopy(threadData, _sb, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))), (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))):(modelica_integer)_count));
#line 16939 OMC_FILE
#line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = _p;
#line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c1 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))));
#line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c2 = 0;
#line 16946 OMC_FILE
            goto tmp3_done;
          }
          case 3: {
            
            /* Pattern matching succeeded */
#line 2719 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            omc_System_stringAllocatorStringCopy(threadData, _sb, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))), (_reverse?(modelica_integer)_len + (-(modelica_integer)_dlen) - stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))) - (modelica_integer)_count:(modelica_integer)_count));
#line 16954 OMC_FILE

#line 2720 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            omc_System_stringAllocatorStringCopy(threadData, _sb, _delimiter, (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - (modelica_integer)_dlen:(modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))))));
#line 16958 OMC_FILE
#line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 3)));
#line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c1 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))) + (modelica_integer)_dlen;
#line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c2 = 1;
#line 16965 OMC_FILE
            goto tmp3_done;
          }
          case 5: {
            
            /* Pattern matching succeeded */
#line 2724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            omc_System_stringAllocatorStringCopy(threadData, _sb, _delimiter, (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - (modelica_integer)_dlen:(modelica_integer)_count));
#line 16973 OMC_FILE
#line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)));
#line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c1 = (modelica_integer)_count + (modelica_integer)_dlen;
#line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp1_c2 = 1;
#line 16980 OMC_FILE
            goto tmp3_done;
          }
          }
          goto tmp3_end;
          tmp3_end: ;
        }
        goto goto_2;
        goto_2:;
        MMC_THROW_INTERNAL();
        goto tmp3_done;
        tmp3_done:;
      }
    }
    _p = tmpMeta[0+0];
    _count = tmp1_c1;
    _b = tmp1_c2;
  }

#line 2729 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _s = omc_System_stringAllocatorResult(threadData, _sb, _s);
#line 17001 OMC_FILE
  _return: OMC_LABEL_UNUSED
  omc_System_StringAllocator_destructor(threadData,_sb);
  return _s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathStripSamePrefix()

DLLExport modelica_metatype omc_Absyn_pathStripSamePrefix	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 15364 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15370 OMC_FILE
  { /* matchcontinue expression */
    {
      modelica_string _ident1 = NULL;
      modelica_string _ident2 = NULL;
      modelica_metatype _path1 = NULL;
      modelica_metatype _path2 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          modelica_boolean tmp5;
          /* Pattern matching succeeded */
#line 3047 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ident1 = omc_Absyn_pathFirstIdent(threadData, _inPath1);
#line 15390 OMC_FILE

#line 3048 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ident2 = omc_Absyn_pathFirstIdent(threadData, _inPath2);
#line 15394 OMC_FILE

#line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (stringEqual(_ident1, _ident2));
#line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 15402 OMC_FILE

#line 3050 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path1 = omc_Absyn_stripFirst(threadData, _inPath1);
#line 15406 OMC_FILE

#line 3051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path2 = omc_Absyn_stripFirst(threadData, _inPath2);
#line 15410 OMC_FILE
#line 3052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_pathStripSamePrefix(threadData, _path1, _path2);
#line 15413 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          /* Pattern matching succeeded */
#line 3055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath1;
#line 15420 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 2) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathSuffixOf()

DLLExport modelica_boolean omc_Absyn_pathSuffixOf	(	threadData_t *	threadData,
		modelica_metatype	_suffix_path,
		modelica_metatype	_path
	)

Definition at line 15029 of file Absyn.c.

{
  modelica_boolean _res;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15036 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;
    tmp4_1 = _path;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 4; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          
          /* Pattern matching succeeded */
#line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = omc_Absyn_pathEqual(threadData, _suffix_path, _path);
#line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 15060 OMC_FILE
#line 3143 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 15063 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p = tmpMeta[0];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3145 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _p);
#line 15073 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 3147 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _p);
#line 15083 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 3148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 15091 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 4) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _res = tmp1;
  _return: OMC_LABEL_UNUSED
  return _res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathSuffixOfr()

DLLExport modelica_boolean omc_Absyn_pathSuffixOfr	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_suffix_path
	)

Definition at line 15008 of file Absyn.c.

{
  modelica_boolean _res;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _res = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _path);
#line 15015 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathToCref()

DLLExport modelica_metatype omc_Absyn_pathToCref	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 11873 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11879 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_string _i = NULL;
      modelica_metatype _c = NULL;
      modelica_metatype _p = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _i = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _i, tmpMeta[1]);
#line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 11901 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _i = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c = omc_Absyn_pathToCref(threadData, _p);
#line 11913 OMC_FILE
#line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _i, tmpMeta[1], _c);
#line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 11920 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4075 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c = omc_Absyn_pathToCref(threadData, _p);
#line 11930 OMC_FILE
#line 4076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c);
#line 11933 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

Here is the caller graph for this function:

omc_Absyn_pathToCrefWithSubs()

DLLExport modelica_metatype omc_Absyn_pathToCrefWithSubs	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_metatype	_inSubs
	)

Definition at line 11795 of file Absyn.c.

{
  modelica_metatype _outComponentRef = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 11801 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_string _i = NULL;
      modelica_metatype _c = NULL;
      modelica_metatype _p = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _i = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4093 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _i, _inSubs);
#line 4093 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 11821 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _i = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 4097 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c = omc_Absyn_pathToCrefWithSubs(threadData, _p, _inSubs);
#line 11833 OMC_FILE
#line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _i, tmpMeta[1], _c);
#line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 11840 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4103 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _c = omc_Absyn_pathToCrefWithSubs(threadData, _p, _inSubs);
#line 11850 OMC_FILE
#line 4104 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c);
#line 11853 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outComponentRef = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outComponentRef;
}

Here is the caller graph for this function:

omc_Absyn_pathToStringList()

DLLExport modelica_metatype omc_Absyn_pathToStringList	(	threadData_t *	threadData,
		modelica_metatype	_path
	)

Definition at line 14992 of file Absyn.c.

{
  modelica_metatype _outPaths = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
#line 3164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outPaths = listReverse(omc_Absyn_pathToStringListWork(threadData, _path, tmpMeta[0]));
#line 15002 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outPaths;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_pathToStringListWork()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_pathToStringListWork	(	threadData_t *	threadData,
		modelica_metatype	_path,
		modelica_metatype	_acc
	)

Definition at line 14909 of file Absyn.c.

{
  modelica_metatype _outPaths = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14915 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _path;
    {
      modelica_string _n = NULL;
      modelica_metatype _p = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _n = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_n, _acc);
#line 3178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 14934 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p;
#line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14950 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _n = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_n, _acc);
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p;
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _acc = tmpMeta[1];
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14972 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPaths = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPaths;
}

Here is the caller graph for this function:

omc_Absyn_pathToTypeSpec()

DLLExport modelica_metatype omc_Absyn_pathToTypeSpec	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 4391 of file Absyn.c.

{
  modelica_metatype _outTypeSpec = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box3(3, &Absyn_TypeSpec_TPATH__desc, _inPath, mmc_mk_none());
#line 5884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outTypeSpec = tmpMeta[0];
#line 4401 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outTypeSpec;
}

omc_Absyn_pathTwoLastIdents()

DLLExport modelica_metatype omc_Absyn_pathTwoLastIdents	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 15872 of file Absyn.c.

{
  modelica_metatype _outTwoLast = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15878 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 2944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath;
#line 15897 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15913 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15929 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outTwoLast = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTwoLast;
}

omc_Absyn_prefixOptPath()

DLLExport modelica_metatype omc_Absyn_prefixOptPath	(	threadData_t *	threadData,
		modelica_string	_prefix,
		modelica_metatype	_optPath
	)

Definition at line 15205 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15211 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _optPath;
    {
      modelica_metatype _path = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!optionNone(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 3098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _prefix);
#line 3098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
#line 15229 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3099 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _prefix, _path);
#line 3099 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
#line 15241 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_prefixPath()

DLLExport modelica_metatype omc_Absyn_prefixPath	(	threadData_t *	threadData,
		modelica_string	_prefix,
		modelica_metatype	_path
	)

Definition at line 15261 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3085 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _prefix, _path);
#line 3085 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outPath = tmpMeta[0];
#line 15271 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_printComponentRefStr()

DLLExport modelica_string omc_Absyn_printComponentRefStr	(	threadData_t *	threadData,
		modelica_metatype	_cr
	)

Definition at line 17769 of file Absyn.c.

{
  modelica_string _ostring = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17776 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _cr;
    {
      modelica_string _s1 = NULL;
      modelica_string _s2 = NULL;
      modelica_metatype _child = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _s1 = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _s1;
#line 17795 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          _s1 = tmpMeta[0];
          _child = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _s2 = omc_Absyn_printComponentRefStr(threadData, _child);
#line 17807 OMC_FILE
#line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = stringAppend(_s1,_OMC_LIT1);
#line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = stringAppend(tmpMeta[0],_s2);
#line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = tmpMeta[1];
#line 17814 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _child = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2538 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _s2 = omc_Absyn_printComponentRefStr(threadData, _child);
#line 17824 OMC_FILE
#line 2539 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = stringAppend(_OMC_LIT1,_s2);
#line 2539 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = tmpMeta[0];
#line 17829 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          
          /* Pattern matching succeeded */
#line 2541 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT57;
#line 17837 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          
          /* Pattern matching succeeded */
#line 2542 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT58;
#line 17845 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _ostring = tmp1;
  _return: OMC_LABEL_UNUSED
  return _ostring;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_printImportString()

DLLExport modelica_string omc_Absyn_printImportString	(	threadData_t *	threadData,
		modelica_metatype	_imp
	)

Definition at line 17938 of file Absyn.c.

{
  modelica_string _ostring = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17945 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _imp;
    {
      modelica_metatype _path = NULL;
      modelica_string _name = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _name = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _name;
#line 17963 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _path = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2483 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
#line 17973 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _path = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
#line 17983 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _ostring = tmp1;
  _return: OMC_LABEL_UNUSED
  return _ostring;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_refString()

DLLExport modelica_string omc_Absyn_refString	(	threadData_t *	threadData,
		modelica_metatype	_inRef
	)

Definition at line 4185 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4192 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inRef;
    {
      modelica_metatype _cr = NULL;
      modelica_metatype _ts = NULL;
      modelica_metatype _im = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _cr = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefString(threadData, _cr);
#line 4210 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _ts = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5964 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_typeSpecString(threadData, _ts);
#line 4220 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _im = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5965 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_importString(threadData, _im);
#line 4230 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outStr = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

omc_Absyn_refStringBrief()

DLLExport modelica_string omc_Absyn_refStringBrief	(	threadData_t *	threadData,
		modelica_metatype	_inRef
	)

Definition at line 4120 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4127 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inRef;
    {
      modelica_metatype _cr = NULL;
      modelica_metatype _ts = NULL;
      modelica_metatype _im = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _cr = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_crefStringIgnoreSubs(threadData, _cr);
#line 4145 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _ts = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5979 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_typeSpecStringNoQualNoDims(threadData, _ts);
#line 4155 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _im = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5980 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_importString(threadData, _im);
#line 4165 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outStr = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

omc_Absyn_removeCrefFromCrefs()

DLLExport modelica_metatype omc_Absyn_removeCrefFromCrefs	(	threadData_t *	threadData,
		modelica_metatype	_inAbsynComponentRefLst,
		modelica_metatype	_inComponentRef
	)

Definition at line 3886 of file Absyn.c.

{
  modelica_metatype _outAbsynComponentRefLst = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3892 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
    tmp3_1 = _inAbsynComponentRefLst;
    tmp3_2 = _inComponentRef;
    {
      modelica_string _n1 = NULL;
      modelica_string _n2 = NULL;
      modelica_metatype _rest_1 = NULL;
      modelica_metatype _rest = NULL;
      modelica_metatype _cr1 = NULL;
      modelica_metatype _cr2 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 4; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          
          tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 6006 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6006 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 3920 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          modelica_boolean tmp5;
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          
          _cr1 = tmpMeta[1];
          _rest = tmpMeta[2];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = _cr1;
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (!listEmpty(tmpMeta[3])) goto goto_1;
#line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _n1 = tmpMeta[2];
#line 3947 OMC_FILE

#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = _cr2;
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (!listEmpty(tmpMeta[3])) goto goto_1;
#line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _n2 = tmpMeta[2];
#line 3963 OMC_FILE

#line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (stringEqual(_n1, _n2));
#line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 3971 OMC_FILE
#line 6012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
#line 3974 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          modelica_boolean tmp6;
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          
          _cr1 = tmpMeta[1];
          _rest = tmpMeta[2];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = _cr1;
#line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,3) == 0) goto goto_1;
#line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _n1 = tmpMeta[2];
#line 3997 OMC_FILE

#line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = _cr2;
#line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
#line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _n2 = tmpMeta[2];
#line 4009 OMC_FILE

#line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_n1, _n2));
#line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_1;
#line 4017 OMC_FILE
#line 6020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
#line 4020 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          
          _cr1 = tmpMeta[1];
          _rest = tmpMeta[2];
          _cr2 = tmp3_2;
          /* Pattern matching succeeded */
#line 6025 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _rest_1 = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
#line 4034 OMC_FILE
#line 6026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_cr1, _rest_1);
#line 6026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 4039 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 4) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outAbsynComponentRefLst = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outAbsynComponentRefLst;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_removePartialPrefix()

DLLExport modelica_metatype omc_Absyn_removePartialPrefix	(	threadData_t *	threadData,
		modelica_metatype	_inPrefix,
		modelica_metatype	_inPath
	)

Definition at line 14276 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14282 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;
    tmp3_1 = _inPrefix;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 4; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          
          /* Pattern matching succeeded */
#line 3345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_removePrefix(threadData, _inPrefix, _inPath);
#line 14301 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _p = tmpMeta[1];
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 3351 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_removePrefix(threadData, _p, _inPath);
#line 14311 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = omc_Absyn_removePartialPrefix(threadData, _p, _inPath);
#line 14321 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          
          /* Pattern matching succeeded */
#line 3361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inPath;
#line 14329 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 4) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_removePrefix()

DLLExport modelica_metatype omc_Absyn_removePrefix	(	threadData_t *	threadData,
		modelica_metatype	_prefix_path,
		modelica_metatype	_path
	)

Definition at line 14356 of file Absyn.c.

{
  modelica_metatype _newPath = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 14362 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _prefix_path;
    tmp3_2 = _path;
    {
      modelica_metatype _p = NULL;
      modelica_metatype _p2 = NULL;
      modelica_string _id1 = NULL;
      modelica_string _id2 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          
          _p2 = tmpMeta[1];
          _p = tmp3_1;
          /* Pattern matching succeeded */
#line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _prefix_path = _p;
#line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p2;
#line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14394 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
          _id1 = tmpMeta[1];
          _p = tmpMeta[2];
          _id2 = tmpMeta[3];
          _p2 = tmpMeta[4];
          /* Pattern matching succeeded */
#line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (stringEqual(_id1, _id2));
#line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp5) goto goto_1;
#line 14416 OMC_FILE
#line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _prefix_path = _p;
#line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = _p2;
#line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 14427 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
          _id1 = tmpMeta[1];
          _id2 = tmpMeta[2];
          _p2 = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (stringEqual(_id1, _id2));
#line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_1;
#line 14447 OMC_FILE
#line 3325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p2;
#line 14450 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _newPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _newPath;
}

Here is the caller graph for this function:

omc_Absyn_restrString()

DLLExport modelica_string omc_Absyn_restrString	(	threadData_t *	threadData,
		modelica_metatype	_inRestriction
	)

Definition at line 10341 of file Absyn.c.

{
  modelica_string _outString = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10348 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inRestriction;
    {
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 20; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4408 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT32;
#line 10363 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4409 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT33;
#line 10371 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4410 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT34;
#line 10379 OMC_FILE
          goto tmp3_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4411 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT35;
#line 10387 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT36;
#line 10395 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT37;
#line 10403 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4414 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT38;
#line 10411 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4415 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT39;
#line 10419 OMC_FILE
          goto tmp3_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4416 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT40;
#line 10427 OMC_FILE
          goto tmp3_done;
        }
        case 9: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4417 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT41;
#line 10439 OMC_FILE
          goto tmp3_done;
        }
        case 10: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT42;
#line 10451 OMC_FILE
          goto tmp3_done;
        }
        case 11: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT43;
#line 10463 OMC_FILE
          goto tmp3_done;
        }
        case 12: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4420 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT44;
#line 10473 OMC_FILE
          goto tmp3_done;
        }
        case 13: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT45;
#line 10481 OMC_FILE
          goto tmp3_done;
        }
        case 14: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT46;
#line 10489 OMC_FILE
          goto tmp3_done;
        }
        case 15: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT47;
#line 10497 OMC_FILE
          goto tmp3_done;
        }
        case 16: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4424 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT48;
#line 10505 OMC_FILE
          goto tmp3_done;
        }
        case 17: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,18,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4426 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT49;
#line 10513 OMC_FILE
          goto tmp3_done;
        }
        case 18: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,19,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT50;
#line 10521 OMC_FILE
          goto tmp3_done;
        }
        case 19: {
          
          /* Pattern matching succeeded */
#line 4430 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT51;
#line 10529 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outString = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the caller graph for this function:

omc_Absyn_selectPathsOpt()

DLLExport modelica_metatype omc_Absyn_selectPathsOpt	(	threadData_t *	threadData,
		modelica_metatype	_inPath1,
		modelica_metatype	_inPath2
	)

Definition at line 12621 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12627 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _inPath1;
    tmp3_2 = _inPath2;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!optionNone(tmp3_1)) goto tmp2_end;
          
          _p = tmp3_2;
          /* Pattern matching succeeded */
#line 3851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 12646 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (optionNone(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
          
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 12657 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_setClassBody()

DLLExport modelica_metatype omc_Absyn_setClassBody	(	threadData_t *	threadData,
		modelica_metatype	_inClass,
		modelica_metatype	_inBody
	)

Definition at line 10114 of file Absyn.c.

{
  modelica_metatype _outClass = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outClass = _inClass;
#line 10121 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outClass;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          
          /* Pattern matching succeeded */
#line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
#line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
#line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[7] = _inBody;
#line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClass = tmpMeta[1];
#line 10142 OMC_FILE
#line 4495 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outClass;
#line 10145 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outClass = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outClass;
}

omc_Absyn_setClassFilename()

DLLExport modelica_metatype omc_Absyn_setClassFilename	(	threadData_t *	threadData,
		modelica_metatype	_inClass,
		modelica_string	_fileName
	)

Definition at line 10216 of file Absyn.c.

{
  modelica_metatype _outClass = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 10222 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inClass;
    {
      modelica_metatype _info = NULL;
      modelica_metatype _cl = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
          
          _cl = tmp3_1;
          _info = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
#line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_info), 9*sizeof(modelica_metatype));
#line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = _fileName;
#line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _info = tmpMeta[1];
#line 10248 OMC_FILE

#line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
#line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_cl), 9*sizeof(modelica_metatype));
#line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[8] = _info;
#line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cl = tmpMeta[1];
#line 10258 OMC_FILE
#line 4467 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _cl;
#line 10261 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outClass = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outClass;
}

Here is the caller graph for this function:

omc_Absyn_setClassName()

DLLExport modelica_metatype omc_Absyn_setClassName	(	threadData_t *	threadData,
		modelica_metatype	_inClass,
		modelica_string	_newName
	)

Definition at line 10165 of file Absyn.c.

{
  modelica_metatype _outClass = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outClass = _inClass;
#line 10172 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outClass;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          
          /* Pattern matching succeeded */
#line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
#line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
#line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = _newName;
#line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClass = tmpMeta[1];
#line 10193 OMC_FILE
#line 4481 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outClass;
#line 10196 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outClass = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outClass;
}

omc_Absyn_splitQualAndIdentPath()

DLLExport modelica_metatype omc_Absyn_splitQualAndIdentPath	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_metatype *	out_outPath2
	)

Definition at line 12219 of file Absyn.c.

{
  modelica_metatype _outPath1 = NULL;
  modelica_metatype _outPath2 = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 3957 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 3957 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 12230 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inPath;
    {
      modelica_metatype _qPath = NULL;
      modelica_metatype _curPath = NULL;
      modelica_metatype _identPath = NULL;
      modelica_string _s1 = NULL;
      modelica_string _s2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],1,1) == 0) goto tmp3_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
          _s1 = tmpMeta[2];
          _s2 = tmpMeta[4];
          /* Pattern matching succeeded */
#line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s1);
#line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s2);
#line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = tmpMeta[3];
#line 12262 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          _s1 = tmpMeta[2];
          _qPath = tmpMeta[3];
          /* Pattern matching succeeded */
#line 3967 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _curPath = omc_Absyn_splitQualAndIdentPath(threadData, _qPath ,&_identPath);
#line 12274 OMC_FILE
#line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _s1, _curPath);
#line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _identPath;
#line 12281 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _qPath = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _qPath;
#line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 12297 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outPath1 = tmpMeta[0+0];
  _outPath2 = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outPath2) { *out_outPath2 = _outPath2; }
  return _outPath1;
}

Here is the caller graph for this function:

omc_Absyn_stringListPath()

DLLExport modelica_metatype omc_Absyn_stringListPath	(	threadData_t *	threadData,
		modelica_metatype	_paths
	)

Definition at line 16056 of file Absyn.c.

{
  modelica_metatype _qualifiedPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 16062 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;
    tmp3_1 = _paths;
    {
      modelica_string _str = NULL;
      modelica_metatype _rest_str = NULL;
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          if (!listEmpty(tmpMeta[2])) goto tmp2_end;
          _str = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2890 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _str);
#line 2890 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 16089 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          _str = tmpMeta[1];
          _rest_str = tmpMeta[2];
          /* Pattern matching succeeded */
#line 2893 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_stringListPath(threadData, _rest_str);
#line 16101 OMC_FILE
#line 2894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p);
#line 2894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 16106 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 2) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _qualifiedPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _qualifiedPath;
}

Here is the caller graph for this function:

omc_Absyn_stringListPathReversed()

DLLExport modelica_metatype omc_Absyn_stringListPathReversed	(	threadData_t *	threadData,
		modelica_metatype	_inStrings
	)

Definition at line 16017 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_string _id = NULL;
  modelica_metatype _rest_str = NULL;
  modelica_metatype _path = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inStrings;
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if (listEmpty(tmpMeta[0])) MMC_THROW_INTERNAL();
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_CAR(tmpMeta[0]);
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_CDR(tmpMeta[0]);
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _id = tmpMeta[1];
#line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _rest_str = tmpMeta[2];
#line 16040 OMC_FILE

#line 2910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
#line 2910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _path = tmpMeta[0];
#line 16046 OMC_FILE

#line 2911 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outPath = omc_Absyn_stringListPathReversed2(threadData, _rest_str, _path);
#line 16050 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_stringListPathReversed2()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stringListPathReversed2	(	threadData_t *	threadData,
		modelica_metatype	_inStrings,
		modelica_metatype	_inAccumPath
	)

Definition at line 15948 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15954 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inStrings;
    {
      modelica_string _id = NULL;
      modelica_metatype _rest_str = NULL;
      modelica_metatype _path = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          /* Pattern matching succeeded */
#line 2925 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inAccumPath;
#line 15972 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          _id = tmpMeta[1];
          _rest_str = tmpMeta[2];
          /* Pattern matching succeeded */
#line 2929 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _id, _inAccumPath);
#line 2929 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = tmpMeta[1];
#line 15986 OMC_FILE
#line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inStrings = _rest_str;
#line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inAccumPath = _path;
#line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 15997 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

omc_Absyn_stringPath()

DLLExport modelica_metatype omc_Absyn_stringPath	(	threadData_t *	threadData,
		modelica_string	_str
	)

Definition at line 16133 of file Absyn.c.

{
  modelica_metatype _qualifiedPath = NULL;
  modelica_metatype _paths = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _paths = omc_Util_stringSplitAtChar(threadData, _str, _OMC_LIT1);
#line 16141 OMC_FILE

#line 2876 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _qualifiedPath = omc_Absyn_stringListPath(threadData, _paths);
#line 16145 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _qualifiedPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_stripClassDefComment()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stripClassDefComment	(	threadData_t *	threadData,
		modelica_metatype	_cl
	)

Definition at line 5777 of file Absyn.c.

{
  modelica_metatype _o = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5783 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _cl;
    {
      modelica_metatype _enumLiterals = NULL;
      modelica_metatype _typeSpec = NULL;
      modelica_metatype _attributes = NULL;
      modelica_metatype _arguments = NULL;
      modelica_metatype _functionNames = NULL;
      modelica_metatype _functionName = NULL;
      modelica_metatype _vars = NULL;
      modelica_metatype _typeVars = NULL;
      modelica_string _baseClassName = NULL;
      modelica_metatype _modifications = NULL;
      modelica_metatype _parts = NULL;
      modelica_metatype _classAttrs = NULL;
      modelica_metatype _ann = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,5) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          
          _typeVars = tmpMeta[1];
          _classAttrs = tmpMeta[2];
          _parts = tmpMeta[3];
          _ann = tmpMeta[4];
          /* Pattern matching succeeded */
#line 5528 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box6(3, &Absyn_ClassDef_PARTS__desc, _typeVars, _classAttrs, _parts, _ann, mmc_mk_none());
#line 5528 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5820 OMC_FILE
          goto tmp2_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,5) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
          _baseClassName = tmpMeta[1];
          _modifications = tmpMeta[2];
          _parts = tmpMeta[3];
          _ann = tmpMeta[4];
          /* Pattern matching succeeded */
#line 5529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box6(7, &Absyn_ClassDef_CLASS__EXTENDS__desc, _baseClassName, _modifications, mmc_mk_none(), _parts, _ann);
#line 5529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5838 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _typeSpec = tmpMeta[1];
          _attributes = tmpMeta[2];
          _arguments = tmpMeta[3];
          /* Pattern matching succeeded */
#line 5530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box5(4, &Absyn_ClassDef_DERIVED__desc, _typeSpec, _attributes, _arguments, mmc_mk_none());
#line 5530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5855 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _enumLiterals = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5531 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_ClassDef_ENUMERATION__desc, _enumLiterals, mmc_mk_none());
#line 5531 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5868 OMC_FILE
          goto tmp2_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _functionNames = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(6, &Absyn_ClassDef_OVERLOAD__desc, _functionNames, mmc_mk_none());
#line 5532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5881 OMC_FILE
          goto tmp2_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _functionName = tmpMeta[1];
          _vars = tmpMeta[2];
          /* Pattern matching succeeded */
#line 5533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(8, &Absyn_ClassDef_PDER__desc, _functionName, _vars, mmc_mk_none());
#line 5533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 5896 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 5534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _cl;
#line 5905 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _o = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _o;
}

Here is the caller graph for this function:

omc_Absyn_stripFirst()

DLLExport modelica_metatype omc_Absyn_stripFirst	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 12159 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12165 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 12183 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Tail recursive call */
#line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _inPath = _p;
#line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto _tailrecursive;
#line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* TODO: Make sure any eventual dead code below is never generated */
#line 12199 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_stripLast()

DLLExport modelica_metatype omc_Absyn_stripLast	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 12468 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12474 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_string _str = NULL;
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp2_end;
          
          _str = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3887 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _str);
#line 3887 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12498 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _str = tmpMeta[1];
          _p = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3891 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_stripLast(threadData, _p);
#line 12510 OMC_FILE
#line 3892 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p);
#line 3892 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12515 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_stripLast(threadData, _p);
#line 12525 OMC_FILE
#line 3898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
#line 3898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 12530 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_stripLastOpt()

DLLExport modelica_metatype omc_Absyn_stripLastOpt	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 12414 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 12420 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 3912 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_none();
#line 12437 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 3916 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _p = omc_Absyn_stripLast(threadData, _inPath);
#line 12445 OMC_FILE
#line 3917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_p);
#line 12448 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the call graph for this function:

omc_Absyn_subModsInSameOrder()

DLLExport modelica_metatype omc_Absyn_subModsInSameOrder	(	threadData_t *	threadData,
		modelica_metatype	_oldmod,
		modelica_metatype	_newmod
	)

Definition at line 4432 of file Absyn.c.

{
  modelica_metatype _mod = NULL;
  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4438 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_metatype tmp3_2;
    tmp3_1 = _oldmod;
    tmp3_2 = _newmod;
    {
      modelica_metatype _args1 = NULL;
      modelica_metatype _args2 = NULL;
      modelica_metatype _res = NULL;
      modelica_metatype _arg2 = NULL;
      modelica_metatype _eq2 = NULL;
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,6) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 5));
          if (!optionNone(tmpMeta[1])) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 5852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _newmod;
#line 4463 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          if (!optionNone(tmpMeta[1])) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 5853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _newmod;
#line 4474 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          if (optionNone(tmpMeta[1])) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,6) == 0) goto tmp2_end;
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 5));
          if (optionNone(tmpMeta[4])) goto tmp2_end;
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 3));
          
          _args1 = tmpMeta[3];
          _arg2 = tmp3_2;
          _args2 = tmpMeta[6];
          _eq2 = tmpMeta[7];
          /* Pattern matching succeeded */
#line 5858 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 5858 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = tmpMeta[1];
#line 4499 OMC_FILE

#line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _arg1;
#line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            for (tmpMeta[1] = _args1; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
#line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            {
#line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _arg1 = MMC_CAR(tmpMeta[1]);
#line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              /* Pattern-matching assignment */
#line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = _arg1;
#line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,6) == 0) goto goto_1;
#line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 4));
#line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              _p = tmpMeta[3];
#line 4521 OMC_FILE

#line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmpMeta[2] = mmc_mk_box1(0, _p);
#line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if(omc_List_exist(threadData, _args2, (modelica_fnptr) mmc_mk_box2(0,closure3_Absyn_isModificationOfPath,tmpMeta[2])))
#line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              {
#line 5862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[3] = mmc_mk_cons(_arg1, _res);
#line 5862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _res = tmpMeta[3];
#line 4533 OMC_FILE
              }
            }
          }

#line 5865 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = listReverse(_res);
#line 4540 OMC_FILE

#line 5867 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _res = omc_Absyn_mergeAnnotations2(threadData, _res, _args2);
#line 4544 OMC_FILE

#line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(3, &Absyn_Modification_CLASSMOD__desc, _res, _eq2);
#line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(8));
#line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_arg2), 8*sizeof(modelica_metatype));
#line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[5] = mmc_mk_some(tmpMeta[2]);
#line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg2 = tmpMeta[1];
#line 4556 OMC_FILE
#line 5869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _arg2;
#line 4559 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _mod = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _mod;
}

omc_Absyn_subscriptEqual()

DLLExport modelica_boolean omc_Absyn_subscriptEqual	(	threadData_t *	threadData,
		modelica_metatype	_inSubscript1,
		modelica_metatype	_inSubscript2
	)

Definition at line 9857 of file Absyn.c.

{
  modelica_boolean _outIsEqual;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 9864 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inSubscript1;
    tmp4_2 = _inSubscript2;
    {
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 4556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 9883 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _e1 = tmpMeta[0];
          _e2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 4557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_expEqual(threadData, _e1, _e2);
#line 9896 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 4558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 9904 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outIsEqual = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outIsEqual;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_subscriptExpOpt()

DLLExport modelica_metatype omc_Absyn_subscriptExpOpt	(	threadData_t *	threadData,
		modelica_metatype	_inSub
	)

Definition at line 7061 of file Absyn.c.

{
  modelica_metatype _outExpOpt = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7067 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inSub;
    {
      modelica_metatype _e = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _e = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_some(_e);
#line 7085 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,0) == 0) goto tmp2_end;
          /* Pattern matching succeeded */
#line 5252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_none();
#line 7093 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outExpOpt = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outExpOpt;
}

omc_Absyn_subscriptsEqual()

DLLExport modelica_boolean omc_Absyn_subscriptsEqual	(	threadData_t *	threadData,
		modelica_metatype	_inSubList1,
		modelica_metatype	_inSubList2
	)

Definition at line 9836 of file Absyn.c.

{
  modelica_boolean _outIsEqual;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4568 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outIsEqual = omc_List_isEqualOnTrue(threadData, _inSubList1, _inSubList2, boxvar_Absyn_subscriptEqual);
#line 9843 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outIsEqual;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_suffixPath()

DLLExport modelica_metatype omc_Absyn_suffixPath	(	threadData_t *	threadData,
		modelica_metatype	_inPath,
		modelica_string	_inSuffix
	)

Definition at line 15126 of file Absyn.c.

{
  modelica_metatype _outPath = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 15132 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inPath;
    {
      modelica_string _name = NULL;
      modelica_metatype _path = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _name = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _inSuffix);
#line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _name, tmpMeta[1]);
#line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 15153 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          _name = tmpMeta[1];
          _path = tmpMeta[2];
          /* Pattern matching succeeded */
#line 3120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = omc_Absyn_suffixPath(threadData, _path, _inSuffix);
#line 15165 OMC_FILE
#line 3121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _name, _path);
#line 3121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 15170 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _path = tmpMeta[1];
          /* Pattern matching succeeded */
#line 3126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _path = omc_Absyn_suffixPath(threadData, _path, _inSuffix);
#line 15180 OMC_FILE
#line 3127 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _path);
#line 3127 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 15185 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outPath = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outPath;
}

Here is the caller graph for this function:

omc_Absyn_traverseAlgorithm()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithm	(	threadData_t *	threadData,
		modelica_metatype	_inAlgorithm,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21232 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 21238 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
    tmp3_1 = _inAlgorithm;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _arg1_1 = NULL;
      modelica_metatype _arg2_1 = NULL;
      modelica_metatype _arg3_1 = NULL;
      modelica_metatype _alg = NULL;
      modelica_metatype _alg_1 = NULL;
      modelica_metatype _ailst = NULL;
      modelica_metatype _ailst1 = NULL;
      modelica_metatype _ailst2 = NULL;
      modelica_metatype _ailst_1 = NULL;
      modelica_metatype _ailst1_1 = NULL;
      modelica_metatype _ailst2_1 = NULL;
      modelica_metatype _eaitlst = NULL;
      modelica_metatype _eaitlst_1 = NULL;
      modelica_fnptr _rel;
      modelica_metatype _e_1 = NULL;
      modelica_metatype _fis_1 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 6; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          
          _alg = tmp3_1;
          _ailst1 = tmpMeta[1];
          _eaitlst = tmpMeta[2];
          _ailst2 = tmpMeta[3];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 4; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst1, ((modelica_fnptr) _rel), _arg);
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst1_1 = tmpMeta[2];
#line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg1_1 = tmpMeta[3];
#line 21296 OMC_FILE

#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _eaitlst, ((modelica_fnptr) _rel), _arg1_1);
#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eaitlst_1 = tmpMeta[2];
#line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg2_1 = tmpMeta[3];
#line 21310 OMC_FILE

#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst2, ((modelica_fnptr) _rel), _arg2_1);
#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst2_1 = tmpMeta[2];
#line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg3_1 = tmpMeta[3];
#line 21324 OMC_FILE

#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg3_1);
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg3_1);
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,4) == 0) goto goto_1;
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e_1 = tmpMeta[5];
#line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[6];
#line 21346 OMC_FILE
#line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box5(4, &Absyn_Algorithm_ALG__IF__desc, _e_1, _ailst1_1, _eaitlst_1, _ailst2_1);
#line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21353 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _alg = tmp3_1;
          _ailst = tmpMeta[1];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst_1 = tmpMeta[2];
#line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg1_1 = tmpMeta[3];
#line 21377 OMC_FILE

#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],2,2) == 0) goto goto_1;
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fis_1 = tmpMeta[5];
#line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[6];
#line 21399 OMC_FILE
#line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(5, &Absyn_Algorithm_ALG__FOR__desc, _fis_1, _ailst_1);
#line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21406 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _alg = tmp3_1;
          _ailst = tmpMeta[1];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst_1 = tmpMeta[2];
#line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg1_1 = tmpMeta[3];
#line 21430 OMC_FILE

#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],3,2) == 0) goto goto_1;
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fis_1 = tmpMeta[5];
#line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[6];
#line 21452 OMC_FILE
#line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(6, &Absyn_Algorithm_ALG__PARFOR__desc, _fis_1, _ailst_1);
#line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21459 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _alg = tmp3_1;
          _ailst = tmpMeta[1];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst_1 = tmpMeta[2];
#line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg1_1 = tmpMeta[3];
#line 21483 OMC_FILE

#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],4,2) == 0) goto goto_1;
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e_1 = tmpMeta[5];
#line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[6];
#line 21505 OMC_FILE
#line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(7, &Absyn_Algorithm_ALG__WHILE__desc, _e_1, _ailst_1);
#line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21512 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _alg = tmp3_1;
          _ailst = tmpMeta[1];
          _eaitlst = tmpMeta[2];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst_1 = tmpMeta[2];
#line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg1_1 = tmpMeta[3];
#line 21538 OMC_FILE

#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _eaitlst, ((modelica_fnptr) _rel), _arg1_1);
#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eaitlst_1 = tmpMeta[2];
#line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg2_1 = tmpMeta[3];
#line 21552 OMC_FILE

#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg2_1);
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg2_1);
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],5,3) == 0) goto goto_1;
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e_1 = tmpMeta[5];
#line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[6];
#line 21574 OMC_FILE
#line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(8, &Absyn_Algorithm_ALG__WHEN__A__desc, _e_1, _ailst_1, _eaitlst_1);
#line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21581 OMC_FILE
          goto tmp2_done;
        }
        case 5: {
          
          _alg = tmp3_1;
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg, _arg);
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _alg, _arg);
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _alg_1 = tmpMeta[4];
#line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[5];
#line 21606 OMC_FILE
#line 1340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _alg_1, _arg_1);
#line 1340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 21611 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 6) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseAlgorithmBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidir	(	threadData_t *	threadData,
		modelica_metatype	_inAlg,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 18244 of file Absyn.c.

{
  modelica_metatype _outAlg = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 18255 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inAlg;
    tmp4_2 = _inArg;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      modelica_metatype _algs1 = NULL;
      modelica_metatype _algs2 = NULL;
      modelica_metatype _else_branch = NULL;
      modelica_metatype _cref1 = NULL;
      modelica_metatype _iters = NULL;
      modelica_metatype _func_args = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _e1 = tmpMeta[2];
          _e2 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18284 OMC_FILE

#line 2339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18288 OMC_FILE
#line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(3, &Absyn_Algorithm_ALG__ASSIGN__desc, _e1, _e2);
#line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18295 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,4) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          
          _e1 = tmpMeta[2];
          _algs1 = tmpMeta[3];
          _else_branch = tmpMeta[4];
          _algs2 = tmpMeta[5];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18313 OMC_FILE

#line 2346 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18317 OMC_FILE

#line 2347 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseAlgorithmBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18321 OMC_FILE

#line 2348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs2 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18325 OMC_FILE
#line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box5(4, &Absyn_Algorithm_ALG__IF__desc, _e1, _algs1, _else_branch, _algs2);
#line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18332 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _iters = tmpMeta[2];
          _algs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18346 OMC_FILE

#line 2354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18350 OMC_FILE
#line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(5, &Absyn_Algorithm_ALG__FOR__desc, _iters, _algs1);
#line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18357 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _iters = tmpMeta[2];
          _algs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2359 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18371 OMC_FILE

#line 2360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18375 OMC_FILE
#line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(6, &Absyn_Algorithm_ALG__PARFOR__desc, _iters, _algs1);
#line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18382 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _e1 = tmpMeta[2];
          _algs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2365 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18396 OMC_FILE

#line 2366 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18400 OMC_FILE
#line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(7, &Absyn_Algorithm_ALG__WHILE__desc, _e1, _algs1);
#line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18407 OMC_FILE
          goto tmp3_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _algs1 = tmpMeta[3];
          _else_branch = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18423 OMC_FILE

#line 2372 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18427 OMC_FILE

#line 2373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseAlgorithmBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18431 OMC_FILE
#line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(8, &Absyn_Algorithm_ALG__WHEN__A__desc, _e1, _algs1, _else_branch);
#line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18438 OMC_FILE
          goto tmp3_done;
        }
        case 9: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _cref1 = tmpMeta[2];
          _func_args = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2378 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18452 OMC_FILE

#line 2379 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _func_args = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _func_args, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18456 OMC_FILE
#line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(9, &Absyn_Algorithm_ALG__NORETCALL__desc, _cref1, _func_args);
#line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18463 OMC_FILE
          goto tmp3_done;
        }
        case 10: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,0) == 0) goto tmp3_end;
          
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inAlg;
#line 2384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18475 OMC_FILE
          goto tmp3_done;
        }
        case 11: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
          
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inAlg;
#line 2387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18487 OMC_FILE
          goto tmp3_done;
        }
        case 14: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,0) == 0) goto tmp3_end;
          
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inAlg;
#line 2390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18499 OMC_FILE
          goto tmp3_done;
        }
        case 12: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _algs1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2394 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18511 OMC_FILE
#line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(12, &Absyn_Algorithm_ALG__FAILURE__desc, _algs1);
#line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18518 OMC_FILE
          goto tmp3_done;
        }
        case 13: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _algs1 = tmpMeta[2];
          _algs2 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18532 OMC_FILE

#line 2401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs2 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18536 OMC_FILE
#line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(13, &Absyn_Algorithm_ALG__TRY__desc, _algs1, _algs2);
#line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18543 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outAlg = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outAlg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseAlgorithmBidirElse()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidirElse	(	threadData_t *	threadData,
		modelica_metatype	_inElse,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 18564 of file Absyn.c.

{
  modelica_metatype _outElse = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype _e = NULL;
  modelica_metatype _algs = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inElse;
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = tmpMeta[1];
#line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _algs = tmpMeta[2];
#line 18585 OMC_FILE

#line 2303 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = omc_Absyn_traverseExpBidir(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
#line 18589 OMC_FILE

#line 2304 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _algs = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18593 OMC_FILE

#line 2305 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(0, _e, _algs);
#line 2305 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outElse = tmpMeta[0];
#line 18599 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outElse;
}

Here is the call graph for this function:

omc_Absyn_traverseAlgorithmItem()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItem	(	threadData_t *	threadData,
		modelica_metatype	_inAlgorithmItem,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21133 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 21139 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
    tmp3_1 = _inAlgorithmItem;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_fnptr _rel;
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _alg = NULL;
      modelica_metatype _alg_1 = NULL;
      modelica_metatype _oc = NULL;
      modelica_metatype _ai = NULL;
      modelica_metatype _info = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _alg = tmpMeta[1];
          _oc = tmpMeta[2];
          _info = tmpMeta[3];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithm(threadData, _alg, ((modelica_fnptr) _rel), _arg);
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _alg_1 = tmpMeta[2];
#line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 21186 OMC_FILE
#line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(3, &Absyn_AlgorithmItem_ALGORITHMITEM__desc, _alg_1, _oc, _info);
#line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21193 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          _ai = tmp3_1;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _ai, _arg);
#line 1373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 21205 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 2) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

omc_Absyn_traverseAlgorithmItemBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemBidir	(	threadData_t *	threadData,
		modelica_metatype	_inAlgorithmItem,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 18981 of file Absyn.c.

{
  modelica_metatype _outAlgorithmItem = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 18992 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inAlgorithmItem;
    tmp4_2 = _inArg;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _alg = NULL;
      modelica_metatype _cmt = NULL;
      modelica_metatype _info = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _alg = tmpMeta[2];
          _cmt = tmpMeta[3];
          _info = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2125 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _alg = omc_Absyn_traverseAlgorithmBidir(threadData, _alg, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19020 OMC_FILE
#line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(3, &Absyn_AlgorithmItem_ALGORITHMITEM__desc, _alg, _cmt, _info);
#line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19027 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 2129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inAlgorithmItem;
#line 2129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19038 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outAlgorithmItem = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outAlgorithmItem;
}

Here is the call graph for this function:

omc_Absyn_traverseAlgorithmItemList()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList	(	threadData_t *	threadData,
		modelica_metatype	_inAlgorithmItemList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21030 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 21036 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_fnptr tmp3_2;modelica_metatype tmp3_3;
    tmp3_1 = _inAlgorithmItemList;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_fnptr _rel;
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _arg_2 = NULL;
      modelica_metatype _ai = NULL;
      modelica_metatype _ai_1 = NULL;
      modelica_metatype _cdr = NULL;
      modelica_metatype _cdr_1 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg);
#line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21067 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          
          _ai = tmpMeta[1];
          _cdr = tmpMeta[2];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItem(threadData, _ai, ((modelica_fnptr) _rel), _arg);
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ai_1 = tmpMeta[2];
#line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 21092 OMC_FILE

#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _cdr, ((modelica_fnptr) _rel), _arg_1);
#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cdr_1 = tmpMeta[2];
#line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[3];
#line 21106 OMC_FILE
#line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(_ai_1, _cdr_1);
#line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
#line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21113 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the caller graph for this function:

omc_Absyn_traverseAlgorithmItemListBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemListBidir	(	threadData_t *	threadData,
		modelica_metatype	_inAlgs,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19059 of file Absyn.c.

{
  modelica_metatype _outAlgs = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outAlgs = omc_List_map2FoldCheckReferenceEq(threadData, _inAlgs, boxvar_Absyn_traverseAlgorithmItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
#line 19067 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outAlgs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseClassComponents()

DLLExport modelica_metatype omc_Absyn_traverseClassComponents	(	threadData_t *	threadData,
		modelica_metatype	_inClass,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 3037 of file Absyn.c.

{
  modelica_metatype _outClass = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outClass = _inClass;
#line 3045 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outClass;
    {
      modelica_metatype _body = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 1; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          
          /* Pattern matching succeeded */
#line 6278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
#line 6278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _body = omc_Absyn_traverseClassDef(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClass), 7))), (modelica_fnptr) mmc_mk_box2(0,closure2_Absyn_traverseClassPartComponents,tmpMeta[1]), _inArg ,&_outArg, NULL);
#line 3063 OMC_FILE

#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if((!referenceEq(_body, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClass), 7))))))
#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[7] = _body;
#line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _outClass = tmpMeta[1];
#line 3077 OMC_FILE
          }
#line 6281 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outClass;
#line 3081 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outClass = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outClass;
}

omc_Absyn_traverseClassDef()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassDef	(	threadData_t *	threadData,
		modelica_metatype	_inClassDef,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2401 of file Absyn.c.

{
  modelica_metatype _outClassDef = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outClassDef = _inClassDef;
  _outArg = _inArg;
  _outContinue = 1;
#line 2412 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outClassDef;
    {
      modelica_metatype _parts = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          
          /* Pattern matching succeeded */
#line 6488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _parts = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassDef), 4))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
#line 2426 OMC_FILE

#line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(7));
#line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassDef), 7*sizeof(modelica_metatype));
#line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = _parts;
#line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClassDef = tmpMeta[0];
#line 2436 OMC_FILE
#line 2437 OMC_FILE
          goto tmp2_done;
        }
        case 7: {
          
          /* Pattern matching succeeded */
#line 6496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _parts = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassDef), 5))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
#line 2445 OMC_FILE

#line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(7));
#line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassDef), 7*sizeof(modelica_metatype));
#line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[5] = _parts;
#line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClassDef = tmpMeta[0];
#line 2455 OMC_FILE
#line 2456 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 2463 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  ;
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outClassDef;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseClassPartBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartBidir	(	threadData_t *	threadData,
		modelica_metatype	_cp,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19087 of file Absyn.c.

{
  modelica_metatype _outCp = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2043 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2043 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19098 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _cp;
    tmp4_2 = _inArg;
    {
      modelica_metatype _algs = NULL;
      modelica_metatype _eqs = NULL;
      modelica_metatype _arg = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _algs = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2050 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _algs = omc_List_map2FoldCheckReferenceEq(threadData, _algs, boxvar_Absyn_traverseAlgorithmItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19121 OMC_FILE
#line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(8, &Absyn_ClassPart_ALGORITHMS__desc, _algs);
#line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19128 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _eqs = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2054 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqs = omc_List_map2FoldCheckReferenceEq(threadData, _eqs, boxvar_Absyn_traverseEquationItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19140 OMC_FILE
#line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(6, &Absyn_ClassPart_EQUATIONS__desc, _eqs);
#line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19147 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outCp = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outCp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseClassPartComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartComponents	(	threadData_t *	threadData,
		modelica_metatype	_inClassPart,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2823 of file Absyn.c.

{
  modelica_metatype _outClassPart = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outClassPart = _inClassPart;
  _outArg = _inArg;
  _outContinue = 1;
#line 2834 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outClassPart;
    {
      modelica_metatype _items = NULL;
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 3: {
          
          /* Pattern matching succeeded */
#line 6345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
#line 6345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _items = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassPart), 2))), (modelica_fnptr) mmc_mk_box2(0,closure0_Absyn_traverseElementItemComponents,tmpMeta[0]), _inArg ,&_outArg ,&_outContinue);
#line 2850 OMC_FILE

#line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassPart), 3*sizeof(modelica_metatype));
#line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = _items;
#line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClassPart = tmpMeta[0];
#line 2860 OMC_FILE
#line 2861 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          
          /* Pattern matching succeeded */
#line 6354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
#line 6354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _items = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassPart), 2))), (modelica_fnptr) mmc_mk_box2(0,closure1_Absyn_traverseElementItemComponents,tmpMeta[0]), _inArg ,&_outArg ,&_outContinue);
#line 2871 OMC_FILE

#line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassPart), 3*sizeof(modelica_metatype));
#line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = _items;
#line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outClassPart = tmpMeta[0];
#line 2881 OMC_FILE
#line 2882 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 2889 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  ;
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outClassPart;
}

Here is the caller graph for this function:

omc_Absyn_traverseElementComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementComponents	(	threadData_t *	threadData,
		modelica_metatype	_inElement,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2605 of file Absyn.c.

{
  modelica_metatype _outElement = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outElement = _inElement;
#line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2621 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _outElement;
    {
      modelica_metatype _spec = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _spec = omc_Absyn_traverseElementSpecComponents(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outElement), 5))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
#line 2638 OMC_FILE

#line 6422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if((!referenceEq(_spec, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outElement), 5))))))
#line 6422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = MMC_TAGPTR(mmc_alloc_words(8));
#line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            memcpy(MMC_UNTAGPTR(tmpMeta[3]), MMC_UNTAGPTR(_outElement), 8*sizeof(modelica_metatype));
#line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[3]))[5] = _spec;
#line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _outElement = tmpMeta[3];
#line 2652 OMC_FILE
          }
#line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _outElement;
#line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _outArg;
#line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = _outContinue;
#line 2660 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inElement;
#line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = 1;
#line 2672 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outElement = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _outContinue = tmp1_c2;
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outElement;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseElementItemComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementItemComponents	(	threadData_t *	threadData,
		modelica_metatype	_inItem,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2705 of file Absyn.c.

{
  modelica_metatype _outItem = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2720 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inItem;
    {
      modelica_metatype _elem = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _elem = omc_Absyn_traverseElementComponents(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inItem), 2))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
#line 2738 OMC_FILE

#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)referenceEq(_elem, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inItem), 2))));
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[4] = _inItem;
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = mmc_mk_box2(3, &Absyn_ElementItem_ELEMENTITEM__desc, _elem);
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[4] = tmpMeta[3];
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outItem = tmpMeta[4];
#line 2762 OMC_FILE
#line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _outItem;
#line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _outArg;
#line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = _outContinue;
#line 2769 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inItem;
#line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = 1;
#line 2781 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outItem = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _outContinue = tmp1_c2;
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outItem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseElementSpecComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementSpecComponents	(	threadData_t *	threadData,
		modelica_metatype	_inSpec,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2494 of file Absyn.c.

{
  modelica_metatype _outSpec = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outSpec = _inSpec;
#line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2510 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _outSpec;
    {
      modelica_metatype _comps = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_integer tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,3) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching tuple assignment */
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))), _inArg, &tmpMeta[3], &tmpMeta[4]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))), _inArg, &tmpMeta[3], &tmpMeta[4]);
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _comps = tmpMeta[5];
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = mmc_unbox_integer(tmpMeta[4]);
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outArg = tmpMeta[3];
#line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outContinue = tmp6  /* pattern as ty=Boolean */;
#line 2538 OMC_FILE

#line 6456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if((!referenceEq(_comps, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))))))
#line 6456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            memcpy(MMC_UNTAGPTR(tmpMeta[3]), MMC_UNTAGPTR(_outSpec), 5*sizeof(modelica_metatype));
#line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[3]))[4] = _comps;
#line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _outSpec = tmpMeta[3];
#line 2552 OMC_FILE
          }
#line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _outSpec;
#line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _outArg;
#line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = _outContinue;
#line 2560 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inSpec;
#line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1_c2 = 1;
#line 2572 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outSpec = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _outContinue = tmp1_c2;
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outSpec;
}

Here is the caller graph for this function:

omc_Absyn_traverseEquation()

DLLExport modelica_metatype omc_Absyn_traverseEquation	(	threadData_t *	threadData,
		modelica_metatype	_inEquation,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21959 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 21965 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
    tmp3_1 = _inEquation;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _arg_2 = NULL;
      modelica_metatype _arg_3 = NULL;
      modelica_metatype _arg_4 = NULL;
      modelica_metatype _eq = NULL;
      modelica_metatype _eq_1 = NULL;
      modelica_fnptr _rel;
      modelica_metatype _e = NULL;
      modelica_metatype _e_1 = NULL;
      modelica_metatype _eqilst = NULL;
      modelica_metatype _eqilst1 = NULL;
      modelica_metatype _eqilst2 = NULL;
      modelica_metatype _eqilst_1 = NULL;
      modelica_metatype _eqilst1_1 = NULL;
      modelica_metatype _eqilst2_1 = NULL;
      modelica_metatype _eeqitlst = NULL;
      modelica_metatype _eeqitlst_1 = NULL;
      modelica_metatype _fis_1 = NULL;
      modelica_metatype _ei = NULL;
      modelica_metatype _ei_1 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 5; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,4) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
          
          _eq = tmp3_1;
          _e = tmpMeta[1];
          _eqilst1 = tmpMeta[2];
          _eeqitlst = tmpMeta[3];
          _eqilst2 = tmpMeta[4];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst1, ((modelica_fnptr) _rel), _arg);
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqilst1_1 = tmpMeta[2];
#line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 22028 OMC_FILE

#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseExpEqItemTupleList(threadData, _eeqitlst, ((modelica_fnptr) _rel), _arg_1);
#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eeqitlst_1 = tmpMeta[2];
#line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[3];
#line 22042 OMC_FILE

#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst2, ((modelica_fnptr) _rel), _arg_2);
#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqilst2_1 = tmpMeta[2];
#line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_3 = tmpMeta[3];
#line 22056 OMC_FILE

#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_3);
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_3);
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],0,4) == 0) goto goto_1;
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_4 = tmpMeta[5];
#line 22074 OMC_FILE
#line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box5(3, &Absyn_Equation_EQ__IF__desc, _e, _eqilst1_1, _eeqitlst_1, _eqilst2_1);
#line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_4);
#line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 22081 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          
          _eq = tmp3_1;
          _eqilst = tmpMeta[1];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst, ((modelica_fnptr) _rel), _arg);
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqilst_1 = tmpMeta[2];
#line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 22105 OMC_FILE

#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_1);
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_1);
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],4,2) == 0) goto goto_1;
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fis_1 = tmpMeta[5];
#line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[6];
#line 22127 OMC_FILE
#line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box3(7, &Absyn_Equation_EQ__FOR__desc, _fis_1, _eqilst_1);
#line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
#line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 22134 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _eq = tmp3_1;
          _eqilst = tmpMeta[1];
          _eeqitlst = tmpMeta[2];
          _rel = tmp3_2;
          _arg = tmp3_3;
          tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst, ((modelica_fnptr) _rel), _arg);
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqilst_1 = tmpMeta[2];
#line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 22160 OMC_FILE

#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseExpEqItemTupleList(threadData, _eeqitlst, ((modelica_fnptr) _rel), _arg_1);
#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eeqitlst_1 = tmpMeta[2];
#line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[3];
#line 22174 OMC_FILE

#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_2);
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_2);
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],5,3) == 0) goto goto_1;
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e_1 = tmpMeta[5];
#line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_3 = tmpMeta[6];
#line 22196 OMC_FILE
#line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(8, &Absyn_Equation_EQ__WHEN__E__desc, _e_1, _eqilst_1, _eeqitlst_1);
#line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_3);
#line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 22203 OMC_FILE
          goto tmp2_done;
        }
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,7,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _eq = tmp3_1;
          _ei = tmpMeta[1];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquationItem(threadData, _ei, ((modelica_fnptr) _rel), _arg);
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ei_1 = tmpMeta[2];
#line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 22227 OMC_FILE

#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_1);
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_1);
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],7,1) == 0) goto goto_1;
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[5];
#line 22245 OMC_FILE
#line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(10, &Absyn_Equation_EQ__FAILURE__desc, _ei_1);
#line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
#line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 22252 OMC_FILE
          goto tmp2_done;
        }
        case 4: {
          
          _eq = tmp3_1;
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq, _arg);
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _eq, _arg);
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eq_1 = tmpMeta[4];
#line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[5];
#line 22277 OMC_FILE
#line 1191 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _eq_1, _arg_1);
#line 1191 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 22282 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 5) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseEquationBidir()

DLLExport modelica_metatype omc_Absyn_traverseEquationBidir	(	threadData_t *	threadData,
		modelica_metatype	_inEquation,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 18647 of file Absyn.c.

{
  modelica_metatype _outEquation = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 18658 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inEquation;
    tmp4_2 = _inArg;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      modelica_metatype _eqil1 = NULL;
      modelica_metatype _eqil2 = NULL;
      modelica_metatype _else_branch = NULL;
      modelica_metatype _cref1 = NULL;
      modelica_metatype _cref2 = NULL;
      modelica_metatype _iters = NULL;
      modelica_metatype _func_args = NULL;
      modelica_metatype _eq = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,4) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          
          _e1 = tmpMeta[2];
          _eqil1 = tmpMeta[3];
          _else_branch = tmpMeta[4];
          _eqil2 = tmpMeta[5];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2197 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18693 OMC_FILE

#line 2198 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18697 OMC_FILE

#line 2199 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseEquationBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18701 OMC_FILE

#line 2200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqil2 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18705 OMC_FILE
#line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box5(3, &Absyn_Equation_EQ__IF__desc, _e1, _eqil1, _else_branch, _eqil2);
#line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18712 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _e1 = tmpMeta[2];
          _e2 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2206 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18726 OMC_FILE

#line 2207 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18730 OMC_FILE
#line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(4, &Absyn_Equation_EQ__EQUALS__desc, _e1, _e2);
#line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18737 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _e2 = tmpMeta[3];
          _cref1 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18753 OMC_FILE

#line 2213 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18757 OMC_FILE

#line 2214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg, NULL);
#line 18761 OMC_FILE
#line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(5, &Absyn_Equation_EQ__PDE__desc, _e1, _e2, _cref1);
#line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18768 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _cref1 = tmpMeta[2];
          _cref2 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18782 OMC_FILE

#line 2221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref2 = omc_Absyn_traverseExpBidirCref(threadData, _cref2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18786 OMC_FILE
#line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(6, &Absyn_Equation_EQ__CONNECT__desc, _cref1, _cref2);
#line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18793 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _iters = tmpMeta[2];
          _eqil1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2227 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18807 OMC_FILE

#line 2228 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18811 OMC_FILE
#line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(7, &Absyn_Equation_EQ__FOR__desc, _iters, _eqil1);
#line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18818 OMC_FILE
          goto tmp3_done;
        }
        case 8: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _eqil1 = tmpMeta[3];
          _else_branch = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2234 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18834 OMC_FILE

#line 2235 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18838 OMC_FILE

#line 2236 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseEquationBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18842 OMC_FILE
#line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(8, &Absyn_Equation_EQ__WHEN__E__desc, _e1, _eqil1, _else_branch);
#line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18849 OMC_FILE
          goto tmp3_done;
        }
        case 9: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _cref1 = tmpMeta[2];
          _func_args = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2242 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18863 OMC_FILE

#line 2243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _func_args = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _func_args, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18867 OMC_FILE
#line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box3(9, &Absyn_Equation_EQ__NORETCALL__desc, _cref1, _func_args);
#line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18874 OMC_FILE
          goto tmp3_done;
        }
        case 10: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _eq = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2249 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eq = omc_Absyn_traverseEquationItemBidir(threadData, _eq, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18886 OMC_FILE
#line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(10, &Absyn_Equation_EQ__FAILURE__desc, _eq);
#line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18893 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outEquation = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outEquation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseEquationBidirElse()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationBidirElse	(	threadData_t *	threadData,
		modelica_metatype	_inElse,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 18605 of file Absyn.c.

{
  modelica_metatype _outElse = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype _e = NULL;
  modelica_metatype _eqil = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inElse;
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = tmpMeta[1];
#line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _eqil = tmpMeta[2];
#line 18626 OMC_FILE

#line 2277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = omc_Absyn_traverseExpBidir(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
#line 18630 OMC_FILE

#line 2278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _eqil = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18634 OMC_FILE

#line 2279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(0, _e, _eqil);
#line 2279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outElse = tmpMeta[0];
#line 18640 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outElse;
}

Here is the call graph for this function:

omc_Absyn_traverseEquationItem()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItem	(	threadData_t *	threadData,
		modelica_metatype	_inEquationItem,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21860 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 21866 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
    tmp3_1 = _inEquationItem;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_metatype _ei = NULL;
      modelica_fnptr _rel;
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _eq = NULL;
      modelica_metatype _eq_1 = NULL;
      modelica_metatype _oc = NULL;
      modelica_metatype _info = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp2_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          
          _eq = tmpMeta[1];
          _oc = tmpMeta[2];
          _info = tmpMeta[3];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseEquation(threadData, _eq, ((modelica_fnptr) _rel), _arg);
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eq_1 = tmpMeta[2];
#line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 21913 OMC_FILE
#line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box4(3, &Absyn_EquationItem_EQUATIONITEM__desc, _eq_1, _oc, _info);
#line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
#line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 21920 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          _ei = tmp3_1;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_box2(0, _ei, _arg);
#line 1223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 21932 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      tmp2_done:
      (void)tmp3;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp2_done2;
      goto_1:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp3 < 2) {
        goto tmp2_top;
      }
      MMC_THROW_INTERNAL();
      tmp2_done2:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseEquationItemBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemBidir	(	threadData_t *	threadData,
		modelica_metatype	_inEquationItem,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 18914 of file Absyn.c.

{
  modelica_metatype _outEquationItem = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 2150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 18925 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inEquationItem;
    tmp4_2 = _inArg;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _eq = NULL;
      modelica_metatype _cmt = NULL;
      modelica_metatype _info = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 1; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _eq = tmpMeta[2];
          _cmt = tmpMeta[3];
          _info = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2159 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _eq = omc_Absyn_traverseEquationBidir(threadData, _eq, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 18953 OMC_FILE
#line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box4(3, &Absyn_EquationItem_EQUATIONITEM__desc, _eq, _cmt, _info);
#line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 18960 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outEquationItem = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outEquationItem;
}

Here is the call graph for this function:

omc_Absyn_traverseEquationItemList()

DLLExport modelica_metatype omc_Absyn_traverseEquationItemList	(	threadData_t *	threadData,
		modelica_metatype	_inEquationItemList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21752 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype _arg2 = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _arg2 = _inTypeA;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _$tmpVar19;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype* tmp1;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _$tmpVar18;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    int tmp6;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype el_loopVar = 0;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _el;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    el_loopVar = _inEquationItemList;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _$tmpVar19 = tmpMeta[1]; /* defaultValue */
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmp1 = &_$tmpVar19;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    while(1) {
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      tmp6 = 1;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      if (!listEmpty(el_loopVar)) {
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        _el = MMC_CAR(el_loopVar);
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        el_loopVar = MMC_CDR(el_loopVar);
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        tmp6--;
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      }
#line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      if (tmp6 == 0) {
#line 21798 OMC_FILE
        { /* match expression */
          modelica_metatype tmp4_1;
          tmp4_1 = _el;
          {
            modelica_metatype _ei = NULL;
            modelica_metatype _ei_1 = NULL;
            volatile mmc_switch_type tmp4;
            int tmp5;
            tmp4 = 0;
            for (; tmp4 < 1; tmp4++) {
              switch (MMC_SWITCH_CAST(tmp4)) {
              case 0: {
                
                _ei = tmp4_1;
                /* Pattern matching succeeded */
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                /* Pattern-matching assignment */
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[3] = omc_Absyn_traverseEquationItem(threadData, _ei, ((modelica_fnptr) _inFunc), _arg2);
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _ei_1 = tmpMeta[4];
#line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _arg2 = tmpMeta[5];
#line 21826 OMC_FILE
#line 1248 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[2] = _ei_1;
#line 21829 OMC_FILE
                goto tmp3_done;
              }
              }
              goto tmp3_end;
              tmp3_end: ;
            }
            goto goto_2;
            goto_2:;
            MMC_THROW_INTERNAL();
            goto tmp3_done;
            tmp3_done:;
          }
        }_$tmpVar18 = tmpMeta[2];
        *tmp1 = mmc_mk_cons(_$tmpVar18,0);
        tmp1 = &MMC_CDR(*tmp1);
      } else if (tmp6 == 1) {
        break;
      } else {
        MMC_THROW_INTERNAL();
      }
    }
    *tmp1 = mmc_mk_nil();
    tmpMeta[0] = _$tmpVar19;
  }
  tmpMeta[3] = mmc_mk_box2(0, tmpMeta[0], _arg2);
  _outTpl = tmpMeta[3];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseEquationItemListBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemListBidir	(	threadData_t *	threadData,
		modelica_metatype	_inEquationItems,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19073 of file Absyn.c.

{
  modelica_metatype _outEquationItems = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 2076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outEquationItems = omc_List_map2FoldCheckReferenceEq(threadData, _inEquationItems, boxvar_Absyn_traverseEquationItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
#line 19081 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outEquationItems;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExp()

DLLExport modelica_metatype omc_Absyn_traverseExp	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 20906 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExp = omc_Absyn_traverseExpBidir(threadData, _inExp, boxvar_Absyn_dummyTraverseExp, ((modelica_fnptr) _inFunc), _inArg ,&_outArg);
#line 20914 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outExp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpAlgItemTupleList()

DLLExport modelica_metatype omc_Absyn_traverseExpAlgItemTupleList	(	threadData_t *	threadData,
		modelica_metatype	_inList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 20921 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 20927 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;modelica_fnptr tmp3_2;modelica_metatype tmp3_3;
    tmp3_1 = _inList;
    tmp3_2 = ((modelica_fnptr) _inFunc);
    tmp3_3 = _inTypeA;
    {
      modelica_fnptr _rel;
      modelica_metatype _arg = NULL;
      modelica_metatype _arg_1 = NULL;
      modelica_metatype _arg_2 = NULL;
      modelica_metatype _cdr = NULL;
      modelica_metatype _cdr_1 = NULL;
      modelica_metatype _e = NULL;
      modelica_metatype _ailst = NULL;
      modelica_metatype _ailst_1 = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (!listEmpty(tmp3_1)) goto tmp2_end;
          
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg);
#line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[2];
#line 20959 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (listEmpty(tmp3_1)) goto tmp2_end;
          tmpMeta[1] = MMC_CAR(tmp3_1);
          tmpMeta[2] = MMC_CDR(tmp3_1);
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
          
          _e = tmpMeta[3];
          _ailst = tmpMeta[4];
          _cdr = tmpMeta[2];
          _rel = tmp3_2;
          _arg = tmp3_3;
          /* Pattern matching succeeded */
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _ailst_1 = tmpMeta[2];
#line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_1 = tmpMeta[3];
#line 20987 OMC_FILE

#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _cdr, ((modelica_fnptr) _rel), _arg_1);
#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cdr_1 = tmpMeta[2];
#line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _arg_2 = tmpMeta[3];
#line 21001 OMC_FILE
#line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(0, _e, _ailst_1);
#line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = mmc_mk_cons(tmpMeta[2], _cdr_1);
#line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
#line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[3];
#line 21010 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outTpl = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the caller graph for this function:

omc_Absyn_traverseExpBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpBidir	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 20838 of file Absyn.c.

{
  modelica_metatype _e = NULL;
  modelica_metatype _arg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1544 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 2))), _inExp, _inArg ,&_arg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 1)))) (threadData, _inExp, _inArg ,&_arg);
#line 20846 OMC_FILE

#line 1545 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = omc_Absyn_traverseExpBidirSubExps(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20850 OMC_FILE

#line 1546 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 2))), _e, _arg ,&_arg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 1)))) (threadData, _e, _arg ,&_arg);
#line 20854 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpBidirCref()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref	(	threadData_t *	threadData,
		modelica_metatype	_inCref,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 19702 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1784 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1784 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19713 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inCref;
    tmp4_2 = _inArg;
    {
      modelica_string _name = NULL;
      modelica_metatype _cr1 = NULL;
      modelica_metatype _cr2 = NULL;
      modelica_metatype _subs1 = NULL;
      modelica_metatype _subs2 = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _cr1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr2 = omc_Absyn_traverseExpBidirCref(threadData, _cr1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19736 OMC_FILE
#line 1794 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = (referenceEq(_cr1, _cr2)?_inCref:omc_Absyn_crefMakeFullyQualified(threadData, _cr2));
#line 1794 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19741 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _name = tmpMeta[2];
          _subs1 = tmpMeta[3];
          _cr1 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _subs2 = omc_List_map2FoldCheckReferenceEq(threadData, _subs1, boxvar_Absyn_traverseExpBidirSubs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19758 OMC_FILE

#line 1800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cr2 = omc_Absyn_traverseExpBidirCref(threadData, _cr1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19762 OMC_FILE
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (modelica_boolean)(referenceEq(_cr1, _cr2) && referenceEq(_subs1, _subs2));
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp5)
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inCref;
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _name, _subs2, _cr2);
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19787 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _name = tmpMeta[2];
          _subs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1806 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _subs2 = omc_List_map2FoldCheckReferenceEq(threadData, _subs1, boxvar_Absyn_traverseExpBidirSubs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19802 OMC_FILE
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)referenceEq(_subs1, _subs2);
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inCref;
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _name, _subs2);
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19827 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inCref;
#line 1810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19838 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inCref;
#line 1811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19849 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outCref = tmpMeta[0+0];
  _arg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outCref;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpBidirElseIf()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirElseIf	(	threadData_t *	threadData,
		modelica_metatype	_inElseIf,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 19567 of file Absyn.c.

{
  modelica_metatype _outElseIf = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype _e1 = NULL;
  modelica_metatype _e2 = NULL;
  modelica_metatype _tup = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inElseIf;
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e1 = tmpMeta[1];
#line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e2 = tmpMeta[2];
#line 19589 OMC_FILE

#line 1873 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
#line 19593 OMC_FILE

#line 1874 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19597 OMC_FILE

#line 1875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box2(0, _e1, _e2);
#line 1875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outElseIf = tmpMeta[0];
#line 19603 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outElseIf;
}

Here is the call graph for this function:

omc_Absyn_traverseExpBidirFunctionArgs()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs	(	threadData_t *	threadData,
		modelica_metatype	_inArgs,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19426 of file Absyn.c.

{
  modelica_metatype _outArgs = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19437 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inArgs;
    tmp4_2 = _inArg;
    {
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      modelica_metatype _expl1 = NULL;
      modelica_metatype _expl2 = NULL;
      modelica_metatype _named_args1 = NULL;
      modelica_metatype _named_args2 = NULL;
      modelica_metatype _iters1 = NULL;
      modelica_metatype _iters2 = NULL;
      modelica_metatype _arg = NULL;
      modelica_metatype _iterType = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _expl1 = tmpMeta[2];
          _named_args1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1908 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19470 OMC_FILE

#line 1909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _named_args2 = omc_List_map2FoldCheckReferenceEq(threadData, _named_args1, boxvar_Absyn_traverseExpBidirNamedArg, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19474 OMC_FILE
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)(referenceEq(_expl1, _expl2) && referenceEq(_named_args1, _named_args2));
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inArgs;
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(3, &Absyn_FunctionArgs_FUNCTIONARGS__desc, _expl2, _named_args2);
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19499 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _iterType = tmpMeta[3];
          _iters1 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1915 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19516 OMC_FILE

#line 1916 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _iters2 = omc_List_map2FoldCheckReferenceEq(threadData, _iters1, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19520 OMC_FILE
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = (modelica_boolean)(referenceEq(_e1, _e2) && referenceEq(_iters1, _iters2));
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp7)
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inArgs;
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(4, &Absyn_FunctionArgs_FOR__ITER__FARG__desc, _e2, _iterType, _iters2);
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19545 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outArgs = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outArgs;
}

Here is the call graph for this function:

omc_Absyn_traverseExpBidirIterator()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirIterator	(	threadData_t *	threadData,
		modelica_metatype	_inIterator,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19300 of file Absyn.c.

{
  modelica_metatype _outIterator = NULL;
  modelica_metatype _outArg = NULL;
  modelica_string _name = NULL;
  modelica_metatype _guardExp1 = NULL;
  modelica_metatype _guardExp2 = NULL;
  modelica_metatype _range1 = NULL;
  modelica_metatype _range2 = NULL;
  modelica_boolean tmp1;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inIterator;
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[1];
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _guardExp1 = tmpMeta[2];
#line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _range1 = tmpMeta[3];
#line 19329 OMC_FILE

#line 1974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _guardExp2 = omc_Absyn_traverseExpOptBidir(threadData, _guardExp1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
#line 19333 OMC_FILE

#line 1975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _range2 = omc_Absyn_traverseExpOptBidir(threadData, _range1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _outArg ,&_outArg);
#line 19337 OMC_FILE

#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp1 = (modelica_boolean)(referenceEq(_guardExp1, _guardExp2) && referenceEq(_range1, _range2));
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if(tmp1)
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = _inIterator;
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  else
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[0] = mmc_mk_box4(3, &Absyn_ForIterator_ITERATOR__desc, _name, _guardExp2, _range2);
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = tmpMeta[0];
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outIterator = tmpMeta[1];
#line 19361 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outIterator;
}

Here is the call graph for this function:

omc_Absyn_traverseExpBidirNamedArg()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirNamedArg	(	threadData_t *	threadData,
		modelica_metatype	_inArg,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inExtra,
		modelica_metatype *	out_outExtra
	)

Definition at line 19368 of file Absyn.c.

{
  modelica_metatype _outArg = NULL;
  modelica_metatype _outExtra = NULL;
  modelica_string _name = NULL;
  modelica_metatype _value1 = NULL;
  modelica_metatype _value2 = NULL;
  modelica_boolean tmp1;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inArg;
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[1];
#line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _value1 = tmpMeta[2];
#line 19391 OMC_FILE

#line 1946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _value2 = omc_Absyn_traverseExpBidir(threadData, _value1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inExtra ,&_outExtra);
#line 19395 OMC_FILE

#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmp1 = (modelica_boolean)referenceEq(_value1, _value2);
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if(tmp1)
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = _inArg;
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  else
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[0] = mmc_mk_box3(3, &Absyn_NamedArg_NAMEDARG__desc, _name, _value2);
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = tmpMeta[0];
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  }
#line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outArg = tmpMeta[1];
#line 19419 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outExtra) { *out_outExtra = _outExtra; }
  return _outArg;
}

Here is the call graph for this function:

omc_Absyn_traverseExpBidirSubExps()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpBidirSubExps	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 19870 of file Absyn.c.

{
  modelica_metatype _e = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1603 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1603 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19881 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inExp;
    tmp4_2 = _inArg;
    {
      modelica_metatype _e1 = NULL;
      modelica_metatype _e1m = NULL;
      modelica_metatype _e2 = NULL;
      modelica_metatype _e2m = NULL;
      modelica_metatype _e3 = NULL;
      modelica_metatype _e3m = NULL;
      modelica_metatype _oe1 = NULL;
      modelica_metatype _oe1m = NULL;
      modelica_metatype _op = NULL;
      modelica_metatype _cref = NULL;
      modelica_metatype _crefm = NULL;
      modelica_metatype _else_ifs1 = NULL;
      modelica_metatype _else_ifs2 = NULL;
      modelica_metatype _expl1 = NULL;
      modelica_metatype _expl2 = NULL;
      modelica_metatype _mat_expl = NULL;
      modelica_metatype _fargs1 = NULL;
      modelica_metatype _fargs2 = NULL;
      modelica_string _error_msg = NULL;
      modelica_string _id = NULL;
      modelica_string _enterName = NULL;
      modelica_string _exitName = NULL;
      modelica_metatype _match_ty = NULL;
      modelica_metatype _match_decls = NULL;
      modelica_metatype _match_cases = NULL;
      modelica_metatype _cmt = NULL;
      int tmp4;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
        case 3: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19924 OMC_FILE
          goto tmp3_done;
        }
        case 4: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1622 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1622 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19935 OMC_FILE
          goto tmp3_done;
        }
        case 6: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1623 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1623 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19946 OMC_FILE
          goto tmp3_done;
        }
        case 7: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19957 OMC_FILE
          goto tmp3_done;
        }
        case 5: {
          modelica_boolean tmp5;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _cref = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1628 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _crefm = omc_Absyn_traverseExpBidirCref(threadData, _cref, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19970 OMC_FILE
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp5 = (modelica_boolean)referenceEq(_cref, _crefm);
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp5)
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _crefm);
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19995 OMC_FILE
          goto tmp3_done;
        }
        case 8: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _op = tmpMeta[3];
          _e2 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20012 OMC_FILE

#line 1635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20016 OMC_FILE
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(8, &Absyn_Exp_BINARY__desc, _e1m, _op, _e2m);
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20041 OMC_FILE
          goto tmp3_done;
        }
        case 9: {
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _op = tmpMeta[2];
          _e1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20056 OMC_FILE
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = (modelica_boolean)referenceEq(_e1, _e1m);
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp7)
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(9, &Absyn_Exp_UNARY__desc, _op, _e1m);
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20081 OMC_FILE
          goto tmp3_done;
        }
        case 10: {
          modelica_boolean tmp8;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _op = tmpMeta[3];
          _e2 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1647 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20098 OMC_FILE

#line 1648 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20102 OMC_FILE
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp8 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp8)
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(10, &Absyn_Exp_LBINARY__desc, _e1m, _op, _e2m);
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20127 OMC_FILE
          goto tmp3_done;
        }
        case 11: {
          modelica_boolean tmp9;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _op = tmpMeta[2];
          _e1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20142 OMC_FILE
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp9 = (modelica_boolean)referenceEq(_e1, _e1m);
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp9)
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(11, &Absyn_Exp_LUNARY__desc, _op, _e1m);
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20167 OMC_FILE
          goto tmp3_done;
        }
        case 12: {
          modelica_boolean tmp10;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _op = tmpMeta[3];
          _e2 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1660 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20184 OMC_FILE

#line 1661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20188 OMC_FILE
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp10 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp10)
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(12, &Absyn_Exp_RELATION__desc, _e1m, _op, _e2m);
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20213 OMC_FILE
          goto tmp3_done;
        }
        case 13: {
          modelica_boolean tmp11;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,4) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          
          _e1 = tmpMeta[2];
          _e2 = tmpMeta[3];
          _e3 = tmpMeta[4];
          _else_ifs1 = tmpMeta[5];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1668 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20232 OMC_FILE

#line 1669 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20236 OMC_FILE

#line 1670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e3m = omc_Absyn_traverseExpBidir(threadData, _e3, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20240 OMC_FILE

#line 1671 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _else_ifs2 = omc_List_map2FoldCheckReferenceEq(threadData, _else_ifs1, boxvar_Absyn_traverseExpBidirElseIf, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20244 OMC_FILE
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp11 = (modelica_boolean)(((referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m)) && referenceEq(_e3, _e3m)) && referenceEq(_else_ifs1, _else_ifs2));
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp11)
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _e1m, _e2m, _e3m, _else_ifs2);
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20269 OMC_FILE
          goto tmp3_done;
        }
        case 14: {
          modelica_boolean tmp12;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _cref = tmpMeta[2];
          _fargs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fargs2 = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _fargs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20284 OMC_FILE
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp12 = (modelica_boolean)referenceEq(_fargs1, _fargs2);
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp12)
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(14, &Absyn_Exp_CALL__desc, _cref, _fargs2);
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20309 OMC_FILE
          goto tmp3_done;
        }
        case 15: {
          modelica_boolean tmp13;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,12,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _cref = tmpMeta[2];
          _fargs1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _fargs2 = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _fargs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20324 OMC_FILE
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp13 = (modelica_boolean)referenceEq(_fargs1, _fargs2);
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp13)
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(15, &Absyn_Exp_PARTEVALFUNCTION__desc, _cref, _fargs2);
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20349 OMC_FILE
          goto tmp3_done;
        }
        case 16: {
          modelica_boolean tmp14;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _expl1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20362 OMC_FILE
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp14 = (modelica_boolean)referenceEq(_expl1, _expl2);
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp14)
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box2(16, &Absyn_Exp_ARRAY__desc, _expl2);
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20387 OMC_FILE
          goto tmp3_done;
        }
        case 17: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _mat_expl = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _mat_expl = omc_List_map2FoldCheckReferenceEq(threadData, _mat_expl, boxvar_Absyn_traverseExpListBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20399 OMC_FILE
#line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box2(17, &Absyn_Exp_MATRIX__desc, _mat_expl);
#line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20406 OMC_FILE
          goto tmp3_done;
        }
        case 18: {
          modelica_boolean tmp15;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,3) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          
          _e1 = tmpMeta[2];
          _oe1 = tmpMeta[3];
          _e2 = tmpMeta[4];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1701 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20423 OMC_FILE

#line 1702 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _oe1m = omc_Absyn_traverseExpOptBidir(threadData, _oe1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20427 OMC_FILE

#line 1703 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20431 OMC_FILE
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp15 = (modelica_boolean)((referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m)) && referenceEq(_oe1, _oe1m));
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp15)
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box4(18, &Absyn_Exp_RANGE__desc, _e1m, _oe1m, _e2m);
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20456 OMC_FILE
          goto tmp3_done;
        }
        case 20: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,17,0) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1707 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1707 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 20467 OMC_FILE
          goto tmp3_done;
        }
        case 19: {
          modelica_boolean tmp16;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _expl1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20480 OMC_FILE
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp16 = (modelica_boolean)referenceEq(_expl1, _expl2);
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp16)
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box2(19, &Absyn_Exp_TUPLE__desc, _expl2);
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20505 OMC_FILE
          goto tmp3_done;
        }
        case 22: {
          modelica_boolean tmp17;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,19,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _id = tmpMeta[2];
          _e1 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1717 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20520 OMC_FILE
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp17 = (modelica_boolean)referenceEq(_e1, _e1m);
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp17)
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(22, &Absyn_Exp_AS__desc, _id, _e1m);
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20545 OMC_FILE
          goto tmp3_done;
        }
        case 23: {
          modelica_boolean tmp18;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,20,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _e1 = tmpMeta[2];
          _e2 = tmpMeta[3];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1723 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20560 OMC_FILE

#line 1724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20564 OMC_FILE
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp18 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp18)
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(23, &Absyn_Exp_CONS__desc, _e1m, _e2m);
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20589 OMC_FILE
          goto tmp3_done;
        }
        case 24: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,21,5) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
          
          _match_ty = tmpMeta[2];
          _e1 = tmpMeta[3];
          _match_decls = tmpMeta[4];
          _match_cases = tmpMeta[5];
          _cmt = tmpMeta[6];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20609 OMC_FILE

#line 1732 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _match_cases = omc_List_map2FoldCheckReferenceEq(threadData, _match_cases, boxvar_Absyn_traverseMatchCase, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20613 OMC_FILE
#line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box6(24, &Absyn_Exp_MATCHEXP__desc, _match_ty, _e1, _match_decls, _match_cases, _cmt);
#line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20620 OMC_FILE
          goto tmp3_done;
        }
        case 25: {
          modelica_boolean tmp19;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,22,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _expl1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1738 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20633 OMC_FILE
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp19 = (modelica_boolean)referenceEq(_expl1, _expl2);
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp19)
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box2(25, &Absyn_Exp_LIST__desc, _expl2);
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20658 OMC_FILE
          goto tmp3_done;
        }
        case 21: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,18,1) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 20669 OMC_FILE
          goto tmp3_done;
        }
        case 26: {
          modelica_boolean tmp20;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,23,2) == 0) goto tmp3_end;
          
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1747 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e1 = omc_Absyn_traverseExpBidir(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2))), ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20680 OMC_FILE

#line 1748 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 3))), ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 20684 OMC_FILE
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp20 = (modelica_boolean)(referenceEq((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2))), _e1) && referenceEq((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 3))), _e2));
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp20)
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inExp;
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box3(26, &Absyn_Exp_DOT__desc, _e1, _e2);
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20709 OMC_FILE
          goto tmp3_done;
        }
        default:
        tmp3_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 1754 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_System_dladdr(threadData, ((modelica_fnptr) _enterFunc) ,NULL ,&_enterName);
#line 20718 OMC_FILE

#line 1755 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_System_dladdr(threadData, ((modelica_fnptr) _exitFunc) ,NULL ,&_exitName);
#line 20722 OMC_FILE

#line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = stringAppend(_OMC_LIT59,_enterName);
#line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[3] = stringAppend(tmpMeta[2],_OMC_LIT3);
#line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[4] = stringAppend(tmpMeta[3],_exitName);
#line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[5] = stringAppend(tmpMeta[4],_OMC_LIT60);
#line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _error_msg = tmpMeta[5];
#line 20734 OMC_FILE

#line 1757 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = stringAppend(_error_msg,omc_Dump_printExpStr(threadData, _inExp));
#line 1757 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _error_msg = tmpMeta[2];
#line 20740 OMC_FILE

#line 1758 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_cons(_error_msg, MMC_REFSTRUCTLIT(mmc_nil));
#line 1758 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          omc_Error_addMessage(threadData, _OMC_LIT65, tmpMeta[2]);
#line 20746 OMC_FILE
#line 1759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          goto goto_2;
#line 20749 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _e = tmpMeta[0+0];
  _arg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpBidirSubs()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirSubs	(	threadData_t *	threadData,
		modelica_metatype	_inSubscript,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 19610 of file Absyn.c.

{
  modelica_metatype _outSubscript = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19621 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inSubscript;
    tmp4_2 = _inArg;
    {
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _e1 = tmpMeta[2];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 1841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
#line 19644 OMC_FILE
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = (modelica_boolean)referenceEq(_e1, _e2);
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if(tmp6)
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = _inSubscript;
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          else
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = mmc_mk_box2(4, &Absyn_Subscript_SUBSCRIPT__desc, _e2);
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = tmpMeta[2];
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[3];
#line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19669 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
          
          /* Pattern matching succeeded */
#line 1845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inSubscript;
#line 1845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 19680 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outSubscript = tmpMeta[0+0];
  _arg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outSubscript;
}

Here is the call graph for this function:

omc_Absyn_traverseExpEqItemTupleList()

DLLExport modelica_metatype omc_Absyn_traverseExpEqItemTupleList	(	threadData_t *	threadData,
		modelica_metatype	_inList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inTypeA
	)

Definition at line 21638 of file Absyn.c.

{
  modelica_metatype _outTpl = NULL;
  modelica_metatype _arg2 = NULL;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _arg2 = _inTypeA;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _$tmpVar17;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype* tmp1;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _$tmpVar16;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    int tmp6;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype el_loopVar = 0;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    modelica_metatype _el;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    el_loopVar = _inList;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _$tmpVar17 = tmpMeta[1]; /* defaultValue */
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmp1 = &_$tmpVar17;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    while(1) {
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      tmp6 = 1;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      if (!listEmpty(el_loopVar)) {
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        _el = MMC_CAR(el_loopVar);
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        el_loopVar = MMC_CDR(el_loopVar);
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
        tmp6--;
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      }
#line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      if (tmp6 == 0) {
#line 21684 OMC_FILE
        { /* match expression */
          modelica_metatype tmp4_1;
          tmp4_1 = _el;
          {
            modelica_metatype _e = NULL;
            modelica_metatype _eilst = NULL;
            modelica_metatype _eilst_1 = NULL;
            volatile mmc_switch_type tmp4;
            int tmp5;
            tmp4 = 0;
            for (; tmp4 < 1; tmp4++) {
              switch (MMC_SWITCH_CAST(tmp4)) {
              case 0: {
                tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
                tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
                _e = tmpMeta[3];
                _eilst = tmpMeta[4];
                /* Pattern matching succeeded */
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                /* Pattern-matching assignment */
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[3] = omc_Absyn_traverseEquationItemList(threadData, _eilst, ((modelica_fnptr) _inFunc), _arg2);
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _eilst_1 = tmpMeta[4];
#line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _arg2 = tmpMeta[5];
#line 21715 OMC_FILE
#line 1275 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[3] = mmc_mk_box2(0, _e, _eilst_1);
#line 1275 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[2] = tmpMeta[3];
#line 21720 OMC_FILE
                goto tmp3_done;
              }
              }
              goto tmp3_end;
              tmp3_end: ;
            }
            goto goto_2;
            goto_2:;
            MMC_THROW_INTERNAL();
            goto tmp3_done;
            tmp3_done:;
          }
        }_$tmpVar16 = tmpMeta[2];
        *tmp1 = mmc_mk_cons(_$tmpVar16,0);
        tmp1 = &MMC_CDR(*tmp1);
      } else if (tmp6 == 1) {
        break;
      } else {
        MMC_THROW_INTERNAL();
      }
    }
    *tmp1 = mmc_mk_nil();
    tmpMeta[0] = _$tmpVar17;
  }
  tmpMeta[4] = mmc_mk_box2(0, tmpMeta[0], _arg2);
  _outTpl = tmpMeta[4];
  _return: OMC_LABEL_UNUSED
  return _outTpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpList()

DLLExport modelica_metatype omc_Absyn_traverseExpList	(	threadData_t *	threadData,
		modelica_metatype	_inExpList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 20876 of file Absyn.c.

{
  modelica_metatype _outExpList = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExpList = omc_Absyn_traverseExpListBidir(threadData, _inExpList, boxvar_Absyn_dummyTraverseExp, ((modelica_fnptr) _inFunc), _inArg ,&_outArg);
#line 20884 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outExpList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpListBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpListBidir	(	threadData_t *	threadData,
		modelica_metatype	_inExpl,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 20861 of file Absyn.c.

{
  modelica_metatype _outExpl = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1517 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExpl = omc_List_map2FoldCheckReferenceEq(threadData, _inExpl, boxvar_Absyn_traverseExpBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
#line 20869 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outExpl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpOptBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_arg
	)

Definition at line 20771 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _arg = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 20782 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inExp;
    {
      modelica_metatype _e1 = NULL;
      modelica_metatype _e2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (optionNone(tmp4_1)) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
          _e1 = tmpMeta[2];
          /* Pattern matching succeeded */
#line 1576 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
#line 20801 OMC_FILE
#line 1577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = (referenceEq(_e1, _e2)?_inExp:mmc_mk_some(_e2));
#line 1577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 20806 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 1580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = _inExp;
#line 1580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _inArg;
#line 20816 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outExp = tmpMeta[0+0];
  _arg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_arg) { *out_arg = _arg; }
  return _outExp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseExpShallow()

DLLExport modelica_metatype omc_Absyn_traverseExpShallow	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_metatype	_inArg,
		modelica_fnptr	_inFunc
	)

Definition at line 1246 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outExp = _inExp;
#line 1253 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outExp;
    {
      int tmp3;
      {
        switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
        case 8: {
          
          /* Pattern matching succeeded */
#line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1272 OMC_FILE

#line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
#line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1282 OMC_FILE
#line 1283 OMC_FILE
          goto tmp2_done;
        }
        case 9: {
          
          /* Pattern matching succeeded */
#line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1297 OMC_FILE
#line 1298 OMC_FILE
          goto tmp2_done;
        }
        case 10: {
          
          /* Pattern matching succeeded */
#line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1312 OMC_FILE

#line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
#line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1322 OMC_FILE
#line 1323 OMC_FILE
          goto tmp2_done;
        }
        case 11: {
          
          /* Pattern matching succeeded */
#line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1337 OMC_FILE
#line 1338 OMC_FILE
          goto tmp2_done;
        }
        case 12: {
          
          /* Pattern matching succeeded */
#line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1352 OMC_FILE

#line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
#line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1362 OMC_FILE
#line 1363 OMC_FILE
          goto tmp2_done;
        }
        case 13: {
          
          /* Pattern matching succeeded */
#line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
#line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
#line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1377 OMC_FILE

#line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
#line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
#line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1387 OMC_FILE

#line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
#line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
#line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
#line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1397 OMC_FILE

#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar5;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp4;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar4;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp5;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype e_loopVar = 0;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _e;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 5)));
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar5 = tmpMeta[2]; /* defaultValue */
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp4 = &_$tmpVar5;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp5 = 1;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(e_loopVar)) {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _e = MMC_CAR(e_loopVar);
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                e_loopVar = MMC_CDR(e_loopVar);
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp5--;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp5 == 0) {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmpMeta[3] = mmc_mk_box2(0, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), omc_Util_tuple21(threadData, _e), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, omc_Util_tuple21(threadData, _e), _inArg), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), omc_Util_tuple22(threadData, _e), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, omc_Util_tuple22(threadData, _e), _inArg));
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar4 = tmpMeta[3];
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp4 = mmc_mk_cons(_$tmpVar4,0);
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp4 = &MMC_CDR(*tmp4);
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp5 == 1) {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp4 = mmc_mk_nil();
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _$tmpVar5;
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[5] = tmpMeta[1];
#line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1471 OMC_FILE
#line 1472 OMC_FILE
          goto tmp2_done;
        }
        case 14: {
          
          /* Pattern matching succeeded */
#line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Absyn_traverseExpShallowFuncArgs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg, ((modelica_fnptr) _inFunc));
#line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1486 OMC_FILE
#line 1487 OMC_FILE
          goto tmp2_done;
        }
        case 15: {
          
          /* Pattern matching succeeded */
#line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Absyn_traverseExpShallowFuncArgs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg, ((modelica_fnptr) _inFunc));
#line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1501 OMC_FILE
#line 1502 OMC_FILE
          goto tmp2_done;
        }
        case 16: {
          
          /* Pattern matching succeeded */
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar7;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp6;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar6;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp7;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype e_loopVar = 0;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _e;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar7 = tmpMeta[2]; /* defaultValue */
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp6 = &_$tmpVar7;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp7 = 1;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(e_loopVar)) {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _e = MMC_CAR(e_loopVar);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                e_loopVar = MMC_CDR(e_loopVar);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp7--;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp7 == 0) {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar6 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp6 = mmc_mk_cons(_$tmpVar6,0);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp6 = &MMC_CDR(*tmp6);
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp7 == 1) {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp6 = mmc_mk_nil();
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _$tmpVar7;
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
#line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1578 OMC_FILE
#line 1579 OMC_FILE
          goto tmp2_done;
        }
        case 17: {
          
          /* Pattern matching succeeded */
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar11;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp8;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar10;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp11;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype lst_loopVar = 0;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _lst;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            lst_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar11 = tmpMeta[2]; /* defaultValue */
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp8 = &_$tmpVar11;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp11 = 1;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(lst_loopVar)) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _lst = MMC_CAR(lst_loopVar);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                lst_loopVar = MMC_CDR(lst_loopVar);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp11--;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp11 == 0) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  modelica_metatype _$tmpVar9;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  modelica_metatype* tmp9;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  modelica_metatype _$tmpVar8;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  int tmp10;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  modelica_metatype e_loopVar = 0;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  modelica_metatype _e;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  e_loopVar = _lst;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  tmpMeta[4] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  _$tmpVar9 = tmpMeta[4]; /* defaultValue */
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  tmp9 = &_$tmpVar9;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  while(1) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    tmp10 = 1;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    if (!listEmpty(e_loopVar)) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      _e = MMC_CAR(e_loopVar);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      e_loopVar = MMC_CDR(e_loopVar);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      tmp10--;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    if (tmp10 == 0) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      _$tmpVar8 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      *tmp9 = mmc_mk_cons(_$tmpVar8,0);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      tmp9 = &MMC_CDR(*tmp9);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    } else if (tmp10 == 1) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      break;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    } else {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                      goto goto_1;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                    }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  *tmp9 = mmc_mk_nil();
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                  tmpMeta[3] = _$tmpVar9;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar10 = tmpMeta[3];
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp8 = mmc_mk_cons(_$tmpVar10,0);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp8 = &MMC_CDR(*tmp8);
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp11 == 1) {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp8 = mmc_mk_nil();
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _$tmpVar11;
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
#line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1717 OMC_FILE
#line 1718 OMC_FILE
          goto tmp2_done;
        }
        case 18: {
          
          /* Pattern matching succeeded */
#line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1732 OMC_FILE

#line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Util_applyOption1(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), ((modelica_fnptr) _inFunc), _inArg);
#line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1742 OMC_FILE

#line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
#line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
#line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1752 OMC_FILE
#line 1753 OMC_FILE
          goto tmp2_done;
        }
        case 19: {
          
          /* Pattern matching succeeded */
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar13;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp12;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar12;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp13;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype e_loopVar = 0;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _e;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar13 = tmpMeta[2]; /* defaultValue */
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp12 = &_$tmpVar13;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp13 = 1;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(e_loopVar)) {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _e = MMC_CAR(e_loopVar);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                e_loopVar = MMC_CDR(e_loopVar);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp13--;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp13 == 0) {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar12 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp12 = mmc_mk_cons(_$tmpVar12,0);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp12 = &MMC_CDR(*tmp12);
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp13 == 1) {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp12 = mmc_mk_nil();
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _$tmpVar13;
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
#line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1829 OMC_FILE
#line 1830 OMC_FILE
          goto tmp2_done;
        }
        case 22: {
          
          /* Pattern matching succeeded */
#line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1844 OMC_FILE
#line 1845 OMC_FILE
          goto tmp2_done;
        }
        case 23: {
          
          /* Pattern matching succeeded */
#line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1859 OMC_FILE

#line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1869 OMC_FILE
#line 1870 OMC_FILE
          goto tmp2_done;
        }
        case 25: {
          
          /* Pattern matching succeeded */
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar15;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp14;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar14;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp15;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype e_loopVar = 0;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _e;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar15 = tmpMeta[2]; /* defaultValue */
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp14 = &_$tmpVar15;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp15 = 1;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(e_loopVar)) {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _e = MMC_CAR(e_loopVar);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                e_loopVar = MMC_CDR(e_loopVar);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp15--;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp15 == 0) {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar14 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp14 = mmc_mk_cons(_$tmpVar14,0);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp14 = &MMC_CDR(*tmp14);
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp15 == 1) {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp14 = mmc_mk_nil();
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[1] = _$tmpVar15;
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
#line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1946 OMC_FILE
#line 1947 OMC_FILE
          goto tmp2_done;
        }
        case 26: {
          
          /* Pattern matching succeeded */
#line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
#line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1961 OMC_FILE

#line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
#line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
#line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outExp = tmpMeta[0];
#line 1971 OMC_FILE
#line 1972 OMC_FILE
          goto tmp2_done;
        }
        default:
        tmp2_default: OMC_LABEL_UNUSED; {
          
          /* Pattern matching succeeded */
#line 1979 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  ;
  _return: OMC_LABEL_UNUSED
  return _outExp;
}

omc_Absyn_traverseExpShallowFuncArgs()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowFuncArgs	(	threadData_t *	threadData,
		modelica_metatype	_inArgs,
		modelica_metatype	_inArg,
		modelica_fnptr	_inFunc
	)

Definition at line 1042 of file Absyn.c.

{
  modelica_metatype _outArgs = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  _outArgs = _inArgs;
#line 1049 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _outArgs;
    {
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar1;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp5;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar0;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp6;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype arg_loopVar = 0;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _arg;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            arg_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2)));
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar1 = tmpMeta[3]; /* defaultValue */
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp5 = &_$tmpVar1;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp6 = 1;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(arg_loopVar)) {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _arg = MMC_CAR(arg_loopVar);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                arg_loopVar = MMC_CDR(arg_loopVar);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp6--;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp6 == 0) {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar0 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _arg, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _arg, _inArg);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp5 = mmc_mk_cons(_$tmpVar0,0);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp5 = &MMC_CDR(*tmp5);
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp6 == 1) {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp5 = mmc_mk_nil();
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = _$tmpVar1;
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(4));
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 4*sizeof(modelica_metatype));
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = tmpMeta[2];
#line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outArgs = tmpMeta[1];
#line 1133 OMC_FILE
#line 6735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outArgs;
#line 1136 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          
          /* Pattern matching succeeded */
#line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 5*sizeof(modelica_metatype));
#line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2))), _inArg);
#line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outArgs = tmpMeta[1];
#line 1151 OMC_FILE

#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar3;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype* tmp7;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _$tmpVar2;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            int tmp8;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype it_loopVar = 0;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            modelica_metatype _it;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            it_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 4)));
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            _$tmpVar3 = tmpMeta[3]; /* defaultValue */
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmp7 = &_$tmpVar3;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            while(1) {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              tmp8 = 1;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (!listEmpty(it_loopVar)) {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _it = MMC_CAR(it_loopVar);
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                it_loopVar = MMC_CDR(it_loopVar);
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp8--;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              if (tmp8 == 0) {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                _$tmpVar2 = omc_Absyn_traverseExpShallowIterator(threadData, _it, _inArg, ((modelica_fnptr) _inFunc));
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                *tmp7 = mmc_mk_cons(_$tmpVar2,0);
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                tmp7 = &MMC_CDR(*tmp7);
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else if (tmp8 == 1) {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                break;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              } else {
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
                goto goto_1;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
              }
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            }
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            *tmp7 = mmc_mk_nil();
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
            tmpMeta[2] = _$tmpVar3;
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          }
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 5*sizeof(modelica_metatype));
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[4] = tmpMeta[2];
#line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _outArgs = tmpMeta[1];
#line 1223 OMC_FILE
#line 6743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _outArgs;
#line 1226 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outArgs = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outArgs;
}

omc_Absyn_traverseExpShallowIterator()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowIterator	(	threadData_t *	threadData,
		modelica_metatype	_inIterator,
		modelica_metatype	_inArg,
		modelica_fnptr	_inFunc
	)

Definition at line 998 of file Absyn.c.

{
  modelica_metatype _outIterator = NULL;
  modelica_string _name = NULL;
  modelica_metatype _guard_exp = NULL;
  modelica_metatype _range_exp = NULL;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  /* Pattern-matching assignment */
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = _inIterator;
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _name = tmpMeta[1];
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _guard_exp = tmpMeta[2];
#line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _range_exp = tmpMeta[3];
#line 1023 OMC_FILE

#line 6765 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _guard_exp = omc_Util_applyOption1(threadData, _guard_exp, ((modelica_fnptr) _inFunc), _inArg);
#line 1027 OMC_FILE

#line 6766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _range_exp = omc_Util_applyOption1(threadData, _range_exp, ((modelica_fnptr) _inFunc), _inArg);
#line 1031 OMC_FILE

#line 6767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  tmpMeta[0] = mmc_mk_box4(3, &Absyn_ForIterator_ITERATOR__desc, _name, _guard_exp, _range_exp);
#line 6767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outIterator = tmpMeta[0];
#line 1037 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outIterator;
}

Here is the call graph for this function:

omc_Absyn_traverseExpTopDown()

DLLExport modelica_metatype omc_Absyn_traverseExpTopDown	(	threadData_t *	threadData,
		modelica_metatype	_inExp,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 20891 of file Absyn.c.

{
  modelica_metatype _outExp = NULL;
  modelica_metatype _outArg = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1477 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outExp = omc_Absyn_traverseExpBidir(threadData, _inExp, ((modelica_fnptr) _inFunc), boxvar_Absyn_dummyTraverseExp, _inArg ,&_outArg);
#line 20899 OMC_FILE
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outExp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_traverseListGeneric()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric	(	threadData_t *	threadData,
		modelica_metatype	_inList,
		modelica_fnptr	_inFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg,
		modelica_boolean *	out_outContinue
	)

Definition at line 2920 of file Absyn.c.

{
  modelica_metatype _outList = NULL;
  modelica_metatype _outArg = NULL;
  modelica_boolean _outContinue;
  modelica_boolean _eq;
  modelica_boolean _changed;
  modelica_metatype _e = NULL;
  modelica_metatype _new_e = NULL;
  modelica_metatype _rest_e = NULL;
  modelica_integer tmp1;
  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
  _outList = tmpMeta[0];
  _outArg = _inArg;
  _outContinue = 1;
  _changed = 0;
  _rest_e = _inList;
#line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  while(1)
#line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if(!(!listEmpty(_rest_e))) break;
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    /* Pattern-matching assignment */
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = _rest_e;
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if (listEmpty(tmpMeta[1])) MMC_THROW_INTERNAL();
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[2] = MMC_CAR(tmpMeta[1]);
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[3] = MMC_CDR(tmpMeta[1]);
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _e = tmpMeta[2];
#line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _rest_e = tmpMeta[3];
#line 2960 OMC_FILE

#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    /* Pattern-matching tuple assignment */
#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _outArg, &tmpMeta[1], &tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _outArg, &tmpMeta[1], &tmpMeta[2]);
#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _new_e = tmpMeta[3];
#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmp1 = mmc_unbox_integer(tmpMeta[2]);
#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _outArg = tmpMeta[1];
#line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _outContinue = tmp1  /* pattern as ty=Boolean */;
#line 2974 OMC_FILE

#line 6310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _eq = referenceEq(_new_e, _e);
#line 2978 OMC_FILE

#line 6311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    tmpMeta[1] = mmc_mk_cons((_eq?_e:_new_e), _outList);
#line 6311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _outList = tmpMeta[1];
#line 2984 OMC_FILE

#line 6312 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _changed = (_changed || (!_eq));
#line 2988 OMC_FILE

#line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    if((!_outContinue))
#line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    {
#line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
      break;
#line 2996 OMC_FILE
    }
  }

#line 6316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  if(_changed)
#line 6316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  {
#line 6317 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _outList = omc_List_append__reverse(threadData, _outList, _rest_e);
#line 3006 OMC_FILE
  }
  else
  {
#line 6319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
    _outList = _inList;
#line 3012 OMC_FILE
  }
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  if (out_outContinue) { *out_outContinue = _outContinue; }
  return _outList;
}

Here is the caller graph for this function:

omc_Absyn_traverseMatchCase()

DLLExport modelica_metatype omc_Absyn_traverseMatchCase	(	threadData_t *	threadData,
		modelica_metatype	_inMatchCase,
		modelica_fnptr	_enterFunc,
		modelica_fnptr	_exitFunc,
		modelica_metatype	_inArg,
		modelica_metatype *	out_outArg
	)

Definition at line 19169 of file Absyn.c.

{
  modelica_metatype _outMatchCase = NULL;
  modelica_metatype _outArg = NULL;
  modelica_metatype tmpMeta[11] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 1996 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 1996 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  
#line 19180 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _inMatchCase;
    tmp4_2 = _inArg;
    {
      modelica_metatype _arg = NULL;
      modelica_metatype _pattern = NULL;
      modelica_metatype _result = NULL;
      modelica_metatype _info = NULL;
      modelica_metatype _resultInfo = NULL;
      modelica_metatype _pinfo = NULL;
      modelica_metatype _ldecls = NULL;
      modelica_metatype _cp = NULL;
      modelica_metatype _cmt = NULL;
      modelica_metatype _patternGuard = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,9) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 7));
          tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 8));
          tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 9));
          tmpMeta[10] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 10));
          
          _pattern = tmpMeta[2];
          _patternGuard = tmpMeta[3];
          _pinfo = tmpMeta[4];
          _ldecls = tmpMeta[5];
          _cp = tmpMeta[6];
          _result = tmpMeta[7];
          _resultInfo = tmpMeta[8];
          _cmt = tmpMeta[9];
          _info = tmpMeta[10];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _pattern = omc_Absyn_traverseExpBidir(threadData, _pattern, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19226 OMC_FILE

#line 2009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _patternGuard = omc_Absyn_traverseExpOptBidir(threadData, _patternGuard, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19230 OMC_FILE

#line 2010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cp = omc_Absyn_traverseClassPartBidir(threadData, _cp, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19234 OMC_FILE

#line 2011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _result = omc_Absyn_traverseExpBidir(threadData, _result, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19238 OMC_FILE
#line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box10(3, &Absyn_Case_CASE__desc, _pattern, _patternGuard, _pinfo, _ldecls, _cp, _result, _resultInfo, _cmt, _info);
#line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19245 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,6) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
          tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
          tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 7));
          
          _ldecls = tmpMeta[2];
          _cp = tmpMeta[3];
          _result = tmpMeta[4];
          _resultInfo = tmpMeta[5];
          _cmt = tmpMeta[6];
          _info = tmpMeta[7];
          _arg = tmp4_2;
          /* Pattern matching succeeded */
#line 2018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _cp = omc_Absyn_traverseClassPartBidir(threadData, _cp, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19267 OMC_FILE

#line 2019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _result = omc_Absyn_traverseExpBidir(threadData, _result, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
#line 19271 OMC_FILE
#line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[2] = mmc_mk_box7(4, &Absyn_Case_ELSE__desc, _ldecls, _cp, _result, _resultInfo, _cmt, _info);
#line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+0] = tmpMeta[2];
#line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0+1] = _arg;
#line 19278 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outMatchCase = tmpMeta[0+0];
  _outArg = tmpMeta[0+1];
  _return: OMC_LABEL_UNUSED
  if (out_outArg) { *out_outArg = _outArg; }
  return _outMatchCase;
}

Here is the call graph for this function:

omc_Absyn_typeSpecDimensions()

DLLExport modelica_metatype omc_Absyn_typeSpecDimensions	(	threadData_t *	threadData,
		modelica_metatype	_inTypeSpec
	)

Definition at line 17194 of file Absyn.c.

{
  modelica_metatype _outDimensions = NULL;
  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17200 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inTypeSpec;
    {
      modelica_metatype _dim = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 3; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
          if (optionNone(tmpMeta[1])) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
          _dim = tmpMeta[2];
          /* Pattern matching succeeded */
#line 2653 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _dim;
#line 17220 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
          if (optionNone(tmpMeta[1])) goto tmp2_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
          _dim = tmpMeta[2];
          /* Pattern matching succeeded */
#line 2654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _dim;
#line 17232 OMC_FILE
          goto tmp2_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 2655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
#line 2655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = tmpMeta[1];
#line 17242 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outDimensions = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outDimensions;
}

omc_Absyn_typeSpecEqual()

DLLExport modelica_boolean omc_Absyn_typeSpecEqual	(	threadData_t *	threadData,
		modelica_metatype	_a,
		modelica_metatype	_b
	)

Definition at line 17468 of file Absyn.c.

{
  modelica_boolean _ob;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17475 OMC_FILE
  { /* matchcontinue expression */
    volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
    tmp4_1 = _a;
    tmp4_2 = _b;
    {
      modelica_metatype _p1 = NULL;
      modelica_metatype _p2 = NULL;
      modelica_metatype _oad1 = NULL;
      modelica_metatype _oad2 = NULL;
      modelica_metatype _lst1 = NULL;
      modelica_metatype _lst2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      MMC_TRY_INTERNAL(mmc_jumper)
      tmp3_top:
      threadData->mmc_jumper = &new_mmc_jumper;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          modelica_boolean tmp6;
          modelica_boolean tmp7;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          _p1 = tmpMeta[0];
          _oad1 = tmpMeta[1];
          _p2 = tmpMeta[2];
          _oad2 = tmpMeta[3];
          tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
#line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp6 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp6) goto goto_2;
#line 17515 OMC_FILE

#line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp7 = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
#line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp7) goto goto_2;
#line 17523 OMC_FILE
#line 2592 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 17526 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          modelica_boolean tmp8;
          modelica_boolean tmp9;
          modelica_boolean tmp10;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
          tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
          tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
          _p1 = tmpMeta[0];
          _lst1 = tmpMeta[1];
          _oad1 = tmpMeta[2];
          _p2 = tmpMeta[3];
          _lst2 = tmpMeta[4];
          _oad2 = tmpMeta[5];
          /* Pattern matching succeeded */
#line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp8 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp8) goto goto_2;
#line 17554 OMC_FILE

#line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp9 = omc_List_isEqualOnTrue(threadData, _lst1, _lst2, boxvar_Absyn_typeSpecEqual);
#line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp9) goto goto_2;
#line 17562 OMC_FILE

#line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          /* Pattern-matching assignment */
#line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp10 = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
#line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          if (1 != tmp10) goto goto_2;
#line 17570 OMC_FILE
#line 2599 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 17573 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 2601 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 17581 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      tmp3_done:
      (void)tmp4;
      MMC_RESTORE_INTERNAL(mmc_jumper);
      goto tmp3_done2;
      goto_2:;
      MMC_CATCH_INTERNAL(mmc_jumper);
      if (++tmp4 < 3) {
        goto tmp3_top;
      }
      MMC_THROW_INTERNAL();
      tmp3_done2:;
    }
  }
  _ob = tmp1;
  _return: OMC_LABEL_UNUSED
  return _ob;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_typeSpecPath()

DLLExport modelica_metatype omc_Absyn_typeSpecPath	(	threadData_t *	threadData,
		modelica_metatype	_tp
	)

Definition at line 17262 of file Absyn.c.

{
  modelica_metatype _op = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17268 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _tp;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2639 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 17287 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          
          _p = tmpMeta[1];
          /* Pattern matching succeeded */
#line 2640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _p;
#line 17298 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _op = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _op;
}

Here is the caller graph for this function:

omc_Absyn_typeSpecPathString()

DLLExport modelica_string omc_Absyn_typeSpecPathString	(	threadData_t *	threadData,
		modelica_metatype	_tp
	)

Definition at line 17318 of file Absyn.c.

{
  modelica_string _s = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 17325 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _tp;
    {
      modelica_metatype _p = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
#line 17344 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _p = tmpMeta[0];
          /* Pattern matching succeeded */
#line 2628 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
#line 17355 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _s = tmp1;
  _return: OMC_LABEL_UNUSED
  return _s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_typeSpecString()

DLLExport modelica_string omc_Absyn_typeSpecString	(	threadData_t *	threadData,
		modelica_metatype	_inTs
	)

Definition at line 4378 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5891 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outStr = omc_Dump_unparseTypeSpec(threadData, _inTs);
#line 4385 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_typeSpecStringNoQualNoDims()

DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDims	(	threadData_t *	threadData,
		modelica_metatype	_inTs
	)

Definition at line 4294 of file Absyn.c.

{
  modelica_string _outStr = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 4301 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _inTs;
    {
      modelica_string _str1 = NULL;
      modelica_string _str2 = NULL;
      modelica_metatype _path = NULL;
      modelica_metatype _typeSpecLst = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          
          _path = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5914 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _path), _OMC_LIT1, 1, 0);
#line 4323 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
          
          _path = tmpMeta[0];
          _typeSpecLst = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str1 = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _path), _OMC_LIT1, 1, 0);
#line 4336 OMC_FILE

#line 5921 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          _str2 = omc_Absyn_typeSpecStringNoQualNoDimsLst(threadData, _typeSpecLst);
#line 4340 OMC_FILE
#line 5922 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = mmc_mk_cons(_str1, mmc_mk_cons(_OMC_LIT4, mmc_mk_cons(_str2, mmc_mk_cons(_OMC_LIT5, MMC_REFSTRUCTLIT(mmc_nil)))));
#line 5922 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = stringAppendList(tmpMeta[0]);
#line 4345 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _outStr = tmp1;
  _return: OMC_LABEL_UNUSED
  return _outStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_typeSpecStringNoQualNoDimsLst()

DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDimsLst	(	threadData_t *	threadData,
		modelica_metatype	_inTypeSpecLst
	)

Definition at line 4281 of file Absyn.c.

{
  modelica_string _outString = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5933 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _outString = omc_List_toString(threadData, _inTypeSpecLst, boxvar_Absyn_typeSpecStringNoQualNoDims, _OMC_LIT2, _OMC_LIT2, _OMC_LIT3, _OMC_LIT2, 0);
#line 4288 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _outString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_unqotePathIdents()

DLLExport modelica_metatype omc_Absyn_unqotePathIdents	(	threadData_t *	threadData,
		modelica_metatype	_inPath
	)

Definition at line 7586 of file Absyn.c.

{
  modelica_metatype _path = NULL;
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 5144 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
  _path = omc_Absyn_stringListPath(threadData, omc_List_map(threadData, omc_Absyn_pathToStringList(threadData, _inPath), boxvar_System_unquoteIdentifier));
#line 7593 OMC_FILE
  _return: OMC_LABEL_UNUSED
  return _path;
}

Here is the call graph for this function:

omc_Absyn_unqualifyCref()

DLLExport modelica_metatype omc_Absyn_unqualifyCref	(	threadData_t *	threadData,
		modelica_metatype	_inCref
	)

Definition at line 7534 of file Absyn.c.

{
  modelica_metatype _outCref = NULL;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7540 OMC_FILE
  { /* match expression */
    modelica_metatype tmp3_1;
    tmp3_1 = _inCref;
    {
      modelica_metatype _cref = NULL;
      volatile mmc_switch_type tmp3;
      int tmp4;
      tmp3 = 0;
      for (; tmp3 < 2; tmp3++) {
        switch (MMC_SWITCH_CAST(tmp3)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
          _cref = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _cref;
#line 7558 OMC_FILE
          goto tmp2_done;
        }
        case 1: {
          
          /* Pattern matching succeeded */
#line 5158 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = _inCref;
#line 7566 OMC_FILE
          goto tmp2_done;
        }
        }
        goto tmp2_end;
        tmp2_end: ;
      }
      goto goto_1;
      goto_1:;
      MMC_THROW_INTERNAL();
      goto tmp2_done;
      tmp2_done:;
    }
  }
  _outCref = tmpMeta[0];
  _return: OMC_LABEL_UNUSED
  return _outCref;
}

Here is the caller graph for this function:

omc_Absyn_withinEqual()

DLLExport modelica_boolean omc_Absyn_withinEqual	(	threadData_t *	threadData,
		modelica_metatype	_within1,
		modelica_metatype	_within2
	)

Definition at line 7285 of file Absyn.c.

{
  modelica_boolean _b;
  modelica_boolean tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7292 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;modelica_metatype tmp4_2;
    tmp4_1 = _within1;
    tmp4_2 = _within2;
    {
      modelica_metatype _p1 = NULL;
      modelica_metatype _p2 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 3; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 1;
#line 7311 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
          tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
          _p1 = tmpMeta[0];
          _p2 = tmpMeta[1];
          /* Pattern matching succeeded */
#line 5201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = omc_Absyn_pathEqual(threadData, _p1, _p2);
#line 7324 OMC_FILE
          goto tmp3_done;
        }
        case 2: {
          
          /* Pattern matching succeeded */
#line 5202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = 0;
#line 7332 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _b = tmp1;
  _return: OMC_LABEL_UNUSED
  return _b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

omc_Absyn_withinString()

DLLExport modelica_string omc_Absyn_withinString	(	threadData_t *	threadData,
		modelica_metatype	_w1
	)

Definition at line 7228 of file Absyn.c.

{
  modelica_string _str = NULL;
  modelica_string tmp1 = 0;
  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
  MMC_SO();
  _tailrecursive: OMC_LABEL_UNUSED
#line 7235 OMC_FILE
  { /* match expression */
    modelica_metatype tmp4_1;
    tmp4_1 = _w1;
    {
      modelica_metatype _p1 = NULL;
      volatile mmc_switch_type tmp4;
      int tmp5;
      tmp4 = 0;
      for (; tmp4 < 2; tmp4++) {
        switch (MMC_SWITCH_CAST(tmp4)) {
        case 0: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
          /* Pattern matching succeeded */
#line 5213 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = _OMC_LIT12;
#line 7251 OMC_FILE
          goto tmp3_done;
        }
        case 1: {
          if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
          tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
          _p1 = tmpMeta[0];
          /* Pattern matching succeeded */
#line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[0] = stringAppend(_OMC_LIT13,omc_Absyn_pathString(threadData, _p1, _OMC_LIT1, 1, 0));
#line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmpMeta[1] = stringAppend(tmpMeta[0],_OMC_LIT14);
#line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
          tmp1 = tmpMeta[1];
#line 7265 OMC_FILE
          goto tmp3_done;
        }
        }
        goto tmp3_end;
        tmp3_end: ;
      }
      goto goto_2;
      goto_2:;
      MMC_THROW_INTERNAL();
      goto tmp3_done;
      tmp3_done:;
    }
  }
  _str = tmp1;
  _return: OMC_LABEL_UNUSED
  return _str;
}